tutanus 0.12.0

package/dist/core/config/config-defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-defaults.d.ts","sourceRoot":"","sources":["../../../src/core/config/config-defaults.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBACy9N,CAAC;mBAAmD,CAAC;0BAA8B,CAAC;;;;;;;;;;;;;;;;CADzhO,CAAC"}

package/dist/core/config/config-defaults.js

@@ -0,0 +1,4 @@
+import { chalk } from './chalk-safe.js';
+import { config } from './config.js';
+export const configDefault = { config, chalk };
+//# sourceMappingURL=config-defaults.js.map

package/dist/core/config/config-defaults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-defaults.js","sourceRoot":"","sources":["../../../src/core/config/config-defaults.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACxC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,MAAM,CAAC,MAAM,aAAa,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC","sourcesContent":["import { chalk } from './chalk-safe.js';\nimport { config } from './config.js';\n\nexport const configDefault = { config, chalk };\n"]}

package/dist/core/config/config.d.ts

@@ -0,0 +1,169 @@
+import type { IncludeExcludeConfig } from '../../types/index.js';
+export declare const configPadrao: {
+    VERBOSE: boolean;
+    LOG_LEVEL: "erro" | "aviso" | "info" | "debug";
+    DEV_MODE: boolean;
+    AUTOANALISE_CONCURRENCY: number;
+    COMPACT_MODE: boolean;
+    SCAN_ONLY: boolean;
+    ANALISE_SCAN_ONLY: boolean;
+    LOG_ESTRUTURADO: boolean;
+    SAFE_MODE: boolean;
+    ALLOW_PLUGINS: boolean;
+    ALLOW_EXEC: boolean;
+    ALLOW_MUTATE_FS: boolean;
+    GUARDIAN_ENABLED: boolean;
+    GUARDIAN_ENFORCE_PROTECTION: boolean;
+    GUARDIAN_BASELINE: string;
+    GUARDIAN_ALLOW_ADDS: boolean;
+    GUARDIAN_ALLOW_CHG: boolean;
+    GUARDIAN_ALLOW_DELS: boolean;
+    REPORT_SILENCE_LOGS: boolean;
+    SUPPRESS_PARCIAL_LOGS: boolean;
+    REPORT_EXPORT_ENABLED: boolean;
+    REPORT_OUTPUT_DIR: string;
+    REPORT_EXPORT_FULL: boolean;
+    REPORT_FRAGMENT_OCCURRENCES: number;
+    REPORT_FRAGMENT_FILEENTRIES: number;
+    REPORT_FRAGMENT_SUMMARY_TOPN: number;
+    REPORT_STREAM_ENABLED: boolean;
+    REPORT_STREAM_AUTO_THRESHOLD: number;
+    REPORT_STREAM_MAX_OCCURRENCES_PER_SHARD: number;
+    REPORT_STREAM_MAX_BYTES_PER_SHARD: number;
+    REPORT_STREAM_COMPRESS: boolean;
+    RELATORIO_SAUDE_TABELA_ENABLED: boolean;
+    RELATORIO_SAUDE_DETALHADO_VERBOSE: boolean;
+    TUTANUS_STATE_DIR: string;
+    ZELADOR_ABANDONED_DIR: string;
+    ZELADOR_PENDING_PATH: string;
+    ZELADOR_REACTIVATE_PATH: string;
+    ZELADOR_HISTORY_PATH: string;
+    ZELADOR_REPORT_PATH: string;
+    ZELADOR_GHOST_INACTIVITY_DAYS: number;
+    ZELADOR_LINE_THRESHOLD: number;
+    CLI_INCLUDE_PATTERNS: string[];
+    CLI_INCLUDE_GROUPS: string[][];
+    CLI_EXCLUDE_PATTERNS: string[];
+    INCLUDE_EXCLUDE_RULES: IncludeExcludeConfig;
+    SCANNER_EXTENSOES_COM_AST: string[];
+    VIGIA_TOP_N: number;
+    ANALISE_LIMITES: {
+        FUNCOES_LONGAS: {
+            MAX_LINHAS: 30;
+            MAX_PARAMETROS: 4;
+            MAX_ANINHAMENTO: 3;
+        };
+        CODIGO_FRAGIL: {
+            MAX_LINHAS_FUNCAO: 30;
+            MAX_PARAMETROS: 4;
+            MAX_NESTED_CALLBACKS: 2;
+        };
+    };
+    ANALISE_AST_CACHE_ENABLED: boolean;
+    ANALISE_METRICAS_ENABLED: boolean;
+    ANALISE_TIMEOUT_POR_ANALISTA_MS: number;
+    ANALISE_METRICAS_HISTORICO_PATH: string;
+    ANALISE_METRICAS_HISTORICO_MAX: number;
+    ANALISE_PRIORIZACAO_ENABLED: boolean;
+    ANALISE_PRIORIZACAO_PESOS: {
+        duracaoMs: number;
+        ocorrencias: number;
+        penalidadeReuso: number;
+    };
+    ANALISE_INCREMENTAL_ENABLED: boolean;
+    ANALISE_INCREMENTAL_STATE_PATH: string;
+    ANALISE_INCREMENTAL_VERSION: number;
+    ANALISE_CACHE_ENABLED: boolean;
+    ANALISE_CACHE_STATE_PATH: string;
+    ANALISE_CACHE_VERSION: number;
+    ANALISE_CACHE_TTL_MS: number;
+    WORKER_POOL_ENABLED: boolean;
+    WORKER_POOL_MAX_WORKERS: number;
+    WORKER_POOL_BATCH_SIZE: number;
+    WORKER_POOL_AUTO_THRESHOLD: number;
+    PARSE_ERRO_AGRUPAR: boolean;
+    PARSE_ERRO_MAX_POR_ARQUIVO: number;
+    PARSE_ERRO_FALHA: boolean;
+    PERF_SNAPSHOT_DIR: string;
+    ESTRUTURA_TARGETS: {
+        TESTS_RAIZ_DIR: string;
+        SCRIPTS_DIR: string;
+        CONFIG_DIR: string;
+        TYPES_DIR: string;
+        DOCS_FRAGMENTS_DIR: string;
+    };
+    conventions: {
+        typesDirectory: string;
+    };
+    nameConventions: {
+        typesDirectory: string;
+        testsDirectory: string;
+        docsDirectory: string;
+        srcDirectory: string;
+        configDirectory: string;
+        scriptsDirectory: string;
+        distDirectory: string;
+        assetsDirectory: string;
+        utilsDirectory: string;
+        servicesDirectory: string;
+        componentsDirectory: string;
+        modelsDirectory: string;
+        middlewareDirectory: string;
+        routesDirectory: string;
+        controllersDirectory: string;
+        viewsDirectory: string;
+        stylesDirectory: string;
+        imagesDirectory: string;
+        localesDirectory: string;
+    };
+    detectorMarkdown: {
+        checkProveniencia: boolean;
+        checkLicenses: boolean;
+        checkReferences: boolean;
+        headerLines: number;
+        whitelist: {
+            paths: string[];
+            patterns: string[];
+            dirs: string[];
+        };
+        whitelistMode: "merge" | "replace";
+    };
+    STRUCTURE_PLUGINS: never[];
+    STRUCTURE_AUTO_FIX: boolean;
+    STRUCTURE_CONCURRENCY: number;
+    ESTRUTURA_CAMADAS: {};
+    STRUCTURE_REVERSE_MAP_PATH: string;
+    ESTRUTURA_PLANO_MAX_FILE_SIZE: number;
+    ESTRUTURA_ARQUIVOS_RAIZ_MAX: number;
+    STATE_DIR: string;
+    ZELADOR_STATE_DIR: string;
+    rules: Record<string, {
+        severity?: "error" | "warning" | "info" | "off";
+        exclude?: string[];
+        allowTestFiles?: boolean;
+    }>;
+    testPadroes: {
+        files: string[];
+        excludeFromOrphanCheck: boolean;
+        allowAnyType: boolean;
+    };
+    LOCALE: string;
+};
+export declare const config: typeof configPadrao & {
+    __OVERRIDES__?: Record<string, {
+        from: unknown;
+        to: unknown;
+        fonte: string;
+    }>;
+};
+type DiffRegistro = {
+    from: unknown;
+    to: unknown;
+    fonte: string;
+};
+export declare function inicializarConfigDinamica(overridesCli?: Record<string, unknown>): Promise<Record<string, DiffRegistro>>;
+export declare function aplicarConfigParcial(partial: Record<string, unknown>): Record<string, DiffRegistro>;
+export declare function inicializarConfigSync(): Record<string, DiffRegistro>;
+export declare function carregarConfigDeDiretorio(diretorio: string): Promise<boolean>;
+export {};
+//# sourceMappingURL=config.d.ts.map

package/dist/core/config/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/core/config/config.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,GAAG,CAAC;AAQ9C,eAAO,MAAM,YAAY;;eAGF,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAkD5B,MAAM,EAAE;wBACV,MAAM,EAAE,EAAE;0BACR,MAAM,EAAE;2BAW/B,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAuGR,MAAM,EAAE;sBACL,MAAM,EAAE;kBACZ,MAAM,EAAE;;uBAEI,OAAO,GAAG,SAAS;;;;;;;;;;;WAelC,MAAM,CAAC,MAAM,EAAE;QAC1B,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,GAAG,KAAK,CAAC;QAChD,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;QACnB,cAAc,CAAC,EAAE,OAAO,CAAC;KAC1B,CAAC;;eAEuF,MAAM,EAAE;;;;YAMjF,MAAM;CACvB,CAAC;AAEF,eAAO,MAAM,MAAM,EAAE,OAAO,YAAY,GAAG;IACzC,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAC7B,IAAI,EAAE,OAAO,CAAC;QACd,EAAE,EAAE,OAAO,CAAC;QACZ,KAAK,EAAE,MAAM,CAAC;KACf,CAAC,CAAC;CAC4B,CAAC;AAElC,KAAK,YAAY,GAAG;IAClB,IAAI,EAAE,OAAO,CAAC;IACd,EAAE,EAAE,OAAO,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAsMF,wBAAsB,yBAAyB,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAa7H;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAOnG;AAED,wBAAgB,qBAAqB,IAAI,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAYpE;AAED,wBAAsB,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAYnF"}

package/dist/core/config/config.js

@@ -0,0 +1,426 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { lerArquivoTexto } from '../../shared/persistence/index.js';
+import { TUTANUS_ARQUIVOS, TUTANUS_DIRS } from '../registry/paths.js';
+import { LIMITES_PADRAO } from './limites.js';
+const TUTANUS_ESTADO = TUTANUS_DIRS.STATE;
+const ZELADOR_ABANDONED = path.join(TUTANUS_ESTADO, 'abandonados');
+export const configPadrao = {
+    VERBOSE: false,
+    LOG_LEVEL: 'info',
+    DEV_MODE: process.env.NODE_ENV === 'development' || process.env.TUTANUS_DEV === 'true',
+    AUTOANALISE_CONCURRENCY: 5,
+    COMPACT_MODE: false,
+    SCAN_ONLY: false,
+    ANALISE_SCAN_ONLY: false,
+    LOG_ESTRUTURADO: false,
+    SAFE_MODE: process.env.VITEST ? false : process.env.TUTANUS_SAFE_MODE !== '0',
+    ALLOW_PLUGINS: process.env.TUTANUS_ALLOW_PLUGINS === '1' || false,
+    ALLOW_EXEC: process.env.TUTANUS_ALLOW_EXEC === '1' || false,
+    ALLOW_MUTATE_FS: true,
+    GUARDIAN_ENABLED: true,
+    GUARDIAN_ENFORCE_PROTECTION: true,
+    GUARDIAN_BASELINE: TUTANUS_ARQUIVOS.GUARDIAN_BASELINE,
+    GUARDIAN_ALLOW_ADDS: false,
+    GUARDIAN_ALLOW_CHG: false,
+    GUARDIAN_ALLOW_DELS: false,
+    REPORT_SILENCE_LOGS: false,
+    SUPPRESS_PARCIAL_LOGS: false,
+    REPORT_EXPORT_ENABLED: false,
+    REPORT_OUTPUT_DIR: TUTANUS_DIRS.REPORTS,
+    REPORT_EXPORT_FULL: false,
+    REPORT_FRAGMENT_OCCURRENCES: 2000,
+    REPORT_FRAGMENT_FILEENTRIES: 500,
+    REPORT_FRAGMENT_SUMMARY_TOPN: 5,
+    REPORT_STREAM_ENABLED: false,
+    REPORT_STREAM_AUTO_THRESHOLD: 5000,
+    REPORT_STREAM_MAX_OCCURRENCES_PER_SHARD: 5000,
+    REPORT_STREAM_MAX_BYTES_PER_SHARD: 10 * 1024 * 1024,
+    REPORT_STREAM_COMPRESS: true,
+    RELATORIO_SAUDE_TABELA_ENABLED: true,
+    RELATORIO_SAUDE_DETALHADO_VERBOSE: true,
+    TUTANUS_STATE_DIR: TUTANUS_ESTADO,
+    ZELADOR_ABANDONED_DIR: ZELADOR_ABANDONED,
+    ZELADOR_PENDING_PATH: path.join(TUTANUS_ESTADO, 'pendentes.json'),
+    ZELADOR_REACTIVATE_PATH: path.join(TUTANUS_ESTADO, 'reativar.json'),
+    ZELADOR_HISTORY_PATH: path.join(TUTANUS_ESTADO, 'historico.json'),
+    ZELADOR_REPORT_PATH: path.join(TUTANUS_ESTADO, 'poda-tutanus.md'),
+    ZELADOR_GHOST_INACTIVITY_DAYS: 30,
+    ZELADOR_LINE_THRESHOLD: 20,
+    CLI_INCLUDE_PATTERNS: [],
+    CLI_INCLUDE_GROUPS: [],
+    CLI_EXCLUDE_PATTERNS: [],
+    INCLUDE_EXCLUDE_RULES: {
+        globalExcludeGlob: [
+            '**/node_modules/**', 'scripts/**', '.pnpm/**', 'out/**', 'build/**', 'dist/**',
+            'coverage/**', '**/.turbo/**', '**/.vercel/**', '**/.expo/**', '**/.parcel-cache/**',
+            '.deprecados/**', '**/deprecados/**', '.pensando/**', '**/pensando/**',
+            '**/.tutanus/**', 'tutanus/**',
+            '**/*.log', '**/*.lock', 'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml',
+            '**/.git/**',
+        ]
+    },
+    SCANNER_EXTENSOES_COM_AST: [
+        '.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs',
+        '.gradle', '.gradle.kts',
+        '.py', '.pyx', '.pyi',
+        '.php', '.phtml', '.php3', '.php4', '.php5', '.php7', '.php8',
+        '.go',
+        '.rs',
+        '.html', '.htm', '.css', '.scss', '.sass',
+        '.xml', '.svg', '.astro',
+        '.sql', '.pgsql', '.mysql', '.sqlite',
+        '.sh', '.bash', '.zsh', '.fish',
+    ],
+    VIGIA_TOP_N: 10,
+    ANALISE_LIMITES: {
+        FUNCOES_LONGAS: {
+            MAX_LINHAS: LIMITES_PADRAO.CODIGO.MAX_LINHAS_FUNCAO,
+            MAX_PARAMETROS: LIMITES_PADRAO.CODIGO.MAX_PARAMETROS_FUNCAO,
+            MAX_ANINHAMENTO: LIMITES_PADRAO.CODIGO.MAX_ANINHAMENTO_IF
+        },
+        CODIGO_FRAGIL: {
+            MAX_LINHAS_FUNCAO: LIMITES_PADRAO.CODIGO.MAX_LINHAS_FUNCAO,
+            MAX_PARAMETROS: LIMITES_PADRAO.CODIGO.MAX_PARAMETROS_FUNCAO,
+            MAX_NESTED_CALLBACKS: LIMITES_PADRAO.CODIGO.MAX_NESTED_CALLBACKS
+        }
+    },
+    ANALISE_AST_CACHE_ENABLED: true,
+    ANALISE_METRICAS_ENABLED: true,
+    ANALISE_TIMEOUT_POR_ANALISTA_MS: 30000,
+    ANALISE_METRICAS_HISTORICO_PATH: path.join(TUTANUS_ESTADO, 'historico-metricas', 'metricas-historico.json'),
+    ANALISE_METRICAS_HISTORICO_MAX: 200,
+    ANALISE_PRIORIZACAO_ENABLED: true,
+    ANALISE_PRIORIZACAO_PESOS: {
+        duracaoMs: 1,
+        ocorrencias: 2,
+        penalidadeReuso: 0.5
+    },
+    ANALISE_INCREMENTAL_ENABLED: false,
+    ANALISE_INCREMENTAL_STATE_PATH: path.join(TUTANUS_ESTADO, 'incremental-analise.json'),
+    ANALISE_INCREMENTAL_VERSION: 1,
+    ANALISE_CACHE_ENABLED: true,
+    ANALISE_CACHE_STATE_PATH: path.join(TUTANUS_ESTADO, 'analysis-cache.json'),
+    ANALISE_CACHE_VERSION: 1,
+    ANALISE_CACHE_TTL_MS: 86400000,
+    WORKER_POOL_ENABLED: true,
+    WORKER_POOL_MAX_WORKERS: 0,
+    WORKER_POOL_BATCH_SIZE: 10,
+    WORKER_POOL_AUTO_THRESHOLD: 50,
+    PARSE_ERRO_AGRUPAR: true,
+    PARSE_ERRO_MAX_POR_ARQUIVO: 1,
+    PARSE_ERRO_FALHA: false,
+    PERF_SNAPSHOT_DIR: path.join('docs', 'perf'),
+    ESTRUTURA_TARGETS: {
+        TESTS_RAIZ_DIR: 'src',
+        SCRIPTS_DIR: path.posix.join('src', 'scripts'),
+        CONFIG_DIR: 'config',
+        TYPES_DIR: 'types',
+        DOCS_FRAGMENTS_DIR: path.posix.join('docs', 'fragments')
+    },
+    conventions: {
+        typesDirectory: path.posix.join('src', 'tipos')
+    },
+    nameConventions: {
+        typesDirectory: 'tipos',
+        testsDirectory: 'testes',
+        docsDirectory: 'docs',
+        srcDirectory: 'src',
+        configDirectory: 'config',
+        scriptsDirectory: 'scripts',
+        distDirectory: 'dist',
+        assetsDirectory: 'assets',
+        utilsDirectory: 'utils',
+        servicesDirectory: 'services',
+        componentsDirectory: 'components',
+        modelsDirectory: 'models',
+        middlewareDirectory: 'middleware',
+        routesDirectory: 'routes',
+        controllersDirectory: 'controllers',
+        viewsDirectory: 'views',
+        stylesDirectory: 'styles',
+        imagesDirectory: 'images',
+        localesDirectory: 'locales'
+    },
+    detectorMarkdown: {
+        checkProveniencia: true,
+        checkLicenses: true,
+        checkReferences: true,
+        headerLines: 30,
+        whitelist: {
+            paths: [],
+            patterns: [],
+            dirs: []
+        },
+        whitelistMode: 'merge'
+    },
+    STRUCTURE_PLUGINS: [],
+    STRUCTURE_AUTO_FIX: false,
+    STRUCTURE_CONCURRENCY: 5,
+    ESTRUTURA_CAMADAS: {},
+    STRUCTURE_REVERSE_MAP_PATH: path.join(TUTANUS_ESTADO, 'mapa-reversao.json'),
+    ESTRUTURA_PLANO_MAX_FILE_SIZE: 256 * 1024,
+    ESTRUTURA_ARQUIVOS_RAIZ_MAX: 10,
+    STATE_DIR: TUTANUS_ESTADO,
+    ZELADOR_STATE_DIR: TUTANUS_ESTADO,
+    rules: {},
+    testPadroes: {
+        files: ['**/*.test.*', '**/*.spec.*', 'test/**/*', 'tests/**/*', '**/__tests__/**'],
+        excludeFromOrphanCheck: true,
+        allowAnyType: false
+    },
+    LOCALE: 'pt'
+};
+export const config = structuredClone(configPadrao);
+function ehObjetoPlano(valor) {
+    return !!valor && typeof valor === 'object' && !Array.isArray(valor);
+}
+function mesclarProfundo(target, src, fonte, diffs, prefix = '') {
+    for (const chave of Object.keys(src || {})) {
+        if (chave === '__proto__' || chave === 'constructor' || chave === 'prototype')
+            continue;
+        const keyCaminho = prefix ? `${prefix}.${chave}` : chave;
+        const srcVal = src[chave];
+        const tgtVal = target[chave];
+        if (ehObjetoPlano(srcVal) && ehObjetoPlano(tgtVal)) {
+            mesclarProfundo(tgtVal, srcVal, fonte, diffs, keyCaminho);
+        }
+        else if (srcVal !== undefined) {
+            if (tgtVal !== srcVal) {
+                diffs[keyCaminho] = { from: tgtVal, to: srcVal, fonte };
+            }
+            target[chave] = srcVal;
+        }
+    }
+}
+function converterConfigSimplificada(config) {
+    const resultado = { ...config };
+    if (config.locale) {
+        resultado.LOCALE = config.locale;
+        delete resultado.locale;
+    }
+    else if (config.locales) {
+        resultado.LOCALE = config.locales;
+        delete resultado.locales;
+    }
+    if (Array.isArray(config.exclude)) {
+        resultado.INCLUDE_EXCLUDE_RULES = {
+            globalExcludeGlob: config.exclude,
+            dirRules: {},
+            defaultExcludes: null
+        };
+        delete resultado.exclude;
+    }
+    if (config.languages && typeof config.languages === 'object') {
+        const langs = config.languages;
+        resultado.languageSupport = {};
+        const langPadroes = {
+            javascript: { parser: 'babel', plugin: 'core' },
+            typescript: { parser: 'babel', plugin: 'core' },
+            html: { parser: 'htmlparser2', plugin: 'core' },
+            css: { parser: 'css-tree', plugin: 'core' },
+            scss: { parser: 'css-tree', plugin: 'core' },
+            sass: { parser: 'css-tree', plugin: 'core' },
+            xml: { parser: 'fast-xml-parser', plugin: 'core' },
+            php: { parser: 'heuristic', plugin: 'core' },
+            python: { parser: 'heuristic', plugin: 'core' },
+            go: { parser: 'heuristic', plugin: 'core' },
+            rust: { parser: 'heuristic', plugin: 'core' },
+            sql: { parser: 'heuristic', plugin: 'core' },
+            shell: { parser: 'heuristic', plugin: 'core' },
+            svg: { parser: 'fast-xml-parser', plugin: 'core' },
+            react: { parser: 'babel', plugin: 'core' },
+            tailwind: { parser: 'heuristic', plugin: 'core' },
+            astro: { parser: 'heuristic', plugin: 'core' },
+            gradle: { parser: 'heuristic', plugin: 'core' },
+        };
+        for (const [lang, enabled] of Object.entries(langs)) {
+            const defaults = langPadroes[lang];
+            if (defaults) {
+                resultado.languageSupport[lang] = {
+                    enabled,
+                    ...defaults
+                };
+            }
+        }
+        const enabledPlugins = ['core'];
+        resultado.plugins = {
+            enabled: enabledPlugins,
+            autoload: true,
+            registry: '@tutanus/plugins'
+        };
+        delete resultado.languages;
+    }
+    if (config.suppress && typeof config.suppress === 'object') {
+        const suppress = config.suppress;
+        if (Array.isArray(suppress.rules))
+            resultado.suppressRules = suppress.rules;
+        if (suppress.severity && typeof suppress.severity === 'object')
+            resultado.suppressBySeverity = suppress.severity;
+        if (Array.isArray(suppress.paths))
+            resultado.suppressByPath = suppress.paths;
+        if (Array.isArray(suppress.filePatterns))
+            resultado.suppressByFilePattern = suppress.filePatterns;
+        delete resultado.suppress;
+    }
+    return resultado;
+}
+function sincronizarIgnorados() {
+    const dyn = (config.INCLUDE_EXCLUDE_RULES || {});
+    const glob = Array.isArray(dyn.globalExcludeGlob) ? dyn.globalExcludeGlob : [];
+    Array.from(new Set(glob.map(grupo => String(grupo))));
+    const cfg = config;
+    delete cfg.ZELADOR_IGNORE_PATTERNS;
+    delete cfg.GUARDIAN_IGNORE_PATTERNS;
+}
+function carregarEnvConfig() {
+    const resultado = {};
+    const stack = [{
+            obj: configPadrao,
+            prefix: ''
+        }];
+    while (stack.length) {
+        const popped = stack.pop();
+        if (!popped)
+            break;
+        const { obj, prefix } = popped;
+        for (const chave of Object.keys(obj)) {
+            const keyCaminho = prefix ? `${prefix}.${chave}` : chave;
+            const envNome = `TUTANUS_${keyCaminho.replace(/\./g, '_').toUpperCase()}`;
+            const currentVal = obj[chave];
+            if (ehObjetoPlano(currentVal)) {
+                stack.push({ obj: currentVal, prefix: keyCaminho });
+            }
+            else {
+                const rawEnv = process.env[envNome];
+                if (rawEnv !== undefined) {
+                    let val = rawEnv;
+                    if (/^(true|false)$/i.test(rawEnv))
+                        val = rawEnv.toLowerCase() === 'true';
+                    else if (/^-?\d+(\.\d+)?$/.test(rawEnv))
+                        val = Number(rawEnv);
+                    atribuirPorCaminho(resultado, keyCaminho, val);
+                }
+            }
+        }
+    }
+    return resultado;
+}
+function isPrototypePollutingKey(key) {
+    return key === '__proto__' || key === 'constructor' || key === 'prototype';
+}
+function atribuirPorCaminho(base, keyCaminho, value) {
+    const parts = keyCaminho.split('.');
+    let cursor = base;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        if (isPrototypePollutingKey(part))
+            return;
+        let next = cursor[part];
+        if (!ehObjetoPlano(next)) {
+            next = {};
+            cursor[part] = next;
+        }
+        cursor = next;
+    }
+    const lastKey = parts[parts.length - 1];
+    if (isPrototypePollutingKey(lastKey))
+        return;
+    cursor[lastKey] = value;
+}
+const configRecord = () => config;
+function sincronizarFlagsScan() {
+    if (config.ANALISE_SCAN_ONLY && !config.SCAN_ONLY)
+        config.SCAN_ONLY = true;
+    else if (config.SCAN_ONLY && !config.ANALISE_SCAN_ONLY)
+        config.ANALISE_SCAN_ONLY = true;
+}
+async function carregarConfigJSON(nome, diretorio) {
+    try {
+        const dir = diretorio || process.cwd();
+        const caminho = path.join(dir, nome);
+        const conteudo = await lerArquivoTexto(caminho);
+        const json = conteudo?.trim() ? JSON.parse(conteudo) : null;
+        if (json)
+            return converterConfigSimplificada(json);
+    }
+    catch {
+    }
+    return null;
+}
+function carregarConfigJSONSync(nome) {
+    try {
+        const caminho = path.join(process.cwd(), nome);
+        const conteudo = fs.readFileSync(caminho, 'utf-8');
+        const json = conteudo?.trim() ? JSON.parse(conteudo) : null;
+        if (json)
+            return converterConfigSimplificada(json);
+    }
+    catch {
+    }
+    return null;
+}
+export async function inicializarConfigDinamica(overridesCli) {
+    const diffs = {};
+    for (const nome of ['tutanus.config.json', 'src/config.json']) {
+        const arquivo = await carregarConfigJSON(nome);
+        if (arquivo) {
+            mesclarProfundo(configRecord(), arquivo, 'arquivo', diffs);
+            break;
+        }
+    }
+    const envCfg = carregarEnvConfig();
+    if (Object.keys(envCfg).length)
+        mesclarProfundo(configRecord(), envCfg, 'env', diffs);
+    if (overridesCli && Object.keys(overridesCli).length)
+        mesclarProfundo(configRecord(), overridesCli, 'cli', diffs);
+    sincronizarFlagsScan();
+    sincronizarIgnorados();
+    config.__OVERRIDES__ = diffs;
+    return diffs;
+}
+export function aplicarConfigParcial(partial) {
+    const diffs = {};
+    mesclarProfundo(configRecord(), partial, 'programatico', diffs);
+    sincronizarFlagsScan();
+    sincronizarIgnorados();
+    config.__OVERRIDES__ = { ...(config.__OVERRIDES__ || {}), ...diffs };
+    return diffs;
+}
+export function inicializarConfigSync() {
+    const diffs = {};
+    for (const nome of ['tutanus.config.json', 'src/config.json']) {
+        const arquivo = carregarConfigJSONSync(nome);
+        if (arquivo) {
+            mesclarProfundo(configRecord(), arquivo, 'arquivo-sync', diffs);
+            break;
+        }
+    }
+    const envCfg = carregarEnvConfig();
+    if (Object.keys(envCfg).length)
+        mesclarProfundo(configRecord(), envCfg, 'env-sync', diffs);
+    sincronizarFlagsScan();
+    sincronizarIgnorados();
+    config.__OVERRIDES__ = { ...(config.__OVERRIDES__ || {}), ...diffs };
+    return diffs;
+}
+export async function carregarConfigDeDiretorio(diretorio) {
+    for (const nome of ['tutanus.config.json', 'src/config.json']) {
+        const convertido = await carregarConfigJSON(nome, diretorio);
+        if (convertido) {
+            const diffs = {};
+            mesclarProfundo(configRecord(), convertido, 'repo-config', diffs);
+            sincronizarIgnorados();
+            config.__OVERRIDES__ = { ...(config.__OVERRIDES__ || {}), ...diffs };
+            return true;
+        }
+    }
+    return false;
+}
+if (!process.env.VITEST) {
+    inicializarConfigSync();
+}
+if (!process.env.VITEST) {
+    void inicializarConfigDinamica();
+}
+//# sourceMappingURL=config.js.map