@silasfmartins/testhub 1.0.0

package/dist/scripts/smart-override.js

@@ -0,0 +1,1360 @@
+#!/usr/bin/env node
+// @ts-nocheck
+/**
+ * 🔧 Smart Override para TypeScript puro
+ * Versão otimizada para desenvolvimento TypeScript sem dependências externas
+ */
+import { execSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+const LOCAL_REGISTRY = path.join(os.homedir(), '.rbqa-local-packages.json');
+const WATCH_REGISTRY = path.join(os.homedir(), '.rbqa-watch-registry.json');
+// 🔒 Pacotes que PREFERENCIALMENTE usam Azure (quando disponível)
+// Se o pacote não existir no Azure ainda, usará versão local automaticamente
+const PREFER_AZURE_PACKAGES = new Set([
+    '@silasfmartins/testhub', // AutoCore prefere Azure, mas usa local se não existir
+]);
+// 🎯 Função para verificar se é um pacote scoped (começa com @)
+// Reconhece: @rbqa/*, @sfa/*, @org/*, etc.
+function isScopedPackage(name) {
+    return name.startsWith('@') && name.includes('/');
+}
+class SmartOverride {
+    buildMetrics = {
+        startTime: Date.now(),
+        compiledFiles: 0,
+        buildSize: '0 KB',
+        success: false,
+        errors: [],
+        warnings: [],
+    };
+    getLocalRegistry() {
+        try {
+            if (fs.existsSync(LOCAL_REGISTRY)) {
+                return JSON.parse(fs.readFileSync(LOCAL_REGISTRY, 'utf8'));
+            }
+        }
+        catch { }
+        return {};
+    }
+    saveLocalRegistry(registry) {
+        fs.writeFileSync(LOCAL_REGISTRY, JSON.stringify(registry, null, 2));
+    }
+    getWatchRegistry() {
+        try {
+            if (fs.existsSync(WATCH_REGISTRY)) {
+                return JSON.parse(fs.readFileSync(WATCH_REGISTRY, 'utf8'));
+            }
+        }
+        catch { }
+        return {};
+    }
+    saveWatchRegistry(registry) {
+        fs.writeFileSync(WATCH_REGISTRY, JSON.stringify(registry, null, 2));
+    }
+    /**
+     * Calcula o tamanho de um diretório recursivamente
+     */
+    calculateDirectorySize(dirPath) {
+        let totalSize = 0;
+        try {
+            const items = fs.readdirSync(dirPath, { withFileTypes: true });
+            for (const item of items) {
+                const itemPath = path.join(dirPath, item.name);
+                if (item.isDirectory()) {
+                    totalSize += this.calculateDirectorySize(itemPath);
+                }
+                else if (item.isFile()) {
+                    totalSize += fs.statSync(itemPath).size;
+                }
+            }
+        }
+        catch (error) {
+            // Ignora erros de acesso a arquivos
+        }
+        return totalSize;
+    }
+    /**
+     * Formata tamanho em bytes para uma string legível
+     */
+    formatSize(bytes) {
+        const units = ['B', 'KB', 'MB', 'GB'];
+        let size = bytes;
+        let unitIndex = 0;
+        while (size >= 1024 && unitIndex < units.length - 1) {
+            size /= 1024;
+            unitIndex++;
+        }
+        return `${size.toFixed(size < 10 ? 1 : 0)} ${units[unitIndex]}`;
+    }
+    /**
+     * Conta arquivos compilados no diretório dist
+     */
+    countCompiledFiles(distPath) {
+        let count = 0;
+        try {
+            const items = fs.readdirSync(distPath, { withFileTypes: true });
+            for (const item of items) {
+                const itemPath = path.join(distPath, item.name);
+                if (item.isDirectory()) {
+                    count += this.countCompiledFiles(itemPath);
+                }
+                else if (item.isFile() &&
+                    (item.name.endsWith('.js') || item.name.endsWith('.d.ts'))) {
+                    count++;
+                }
+            }
+        }
+        catch (error) {
+            // Ignora erros
+        }
+        return count;
+    }
+    /**
+     * Formata duração em milissegundos para string legível
+     */
+    formatDuration(ms) {
+        if (ms < 1000) {
+            return `${ms}ms`;
+        }
+        if (ms < 60_000) {
+            return `${(ms / 1000).toFixed(1)}s`;
+        }
+        const minutes = Math.floor(ms / 60_000);
+        const seconds = ((ms % 60_000) / 1000).toFixed(1);
+        return `${minutes}m ${seconds}s`;
+    }
+    /**
+     * Exibe banner de início do build
+     */
+    showBuildStartBanner(packageName, version) {
+        const line = '═'.repeat(80);
+        console.log(`\n${line}`);
+        console.log(`🏗️  INICIANDO BUILD - ${packageName}@${version}`);
+        console.log(`${line}`);
+        console.log(`📅 Timestamp: ${new Date().toLocaleString('pt-BR')}`);
+        console.log(`🖥️  Sistema: ${os.platform()} ${os.arch()}`);
+        console.log(`⚡ Node.js: ${process.version}`);
+        console.log(`📂 Diretório: ${process.cwd()}`);
+        console.log(`${line}\n`);
+    }
+    /**
+     * Exibe resumo detalhado do build
+     */
+    showBuildSummary(packageName, version) {
+        this.buildMetrics.endTime = Date.now();
+        this.buildMetrics.duration =
+            this.buildMetrics.endTime - this.buildMetrics.startTime;
+        const line = '═'.repeat(80);
+        const statusIcon = this.buildMetrics.success ? '✅' : '❌';
+        const statusText = this.buildMetrics.success ? 'SUCESSO' : 'FALHOU';
+        console.log(`\n${line}`);
+        console.log(`${statusIcon} BUILD ${statusText} - ${packageName}@${version}`);
+        console.log(`${line}`);
+        // Métricas principais
+        console.log(`⏱️  Duração total: ${this.formatDuration(this.buildMetrics.duration)}`);
+        console.log(`📁 Arquivos compilados: ${this.buildMetrics.compiledFiles}`);
+        console.log(`📦 Tamanho do build: ${this.buildMetrics.buildSize}`);
+        console.log(`🕐 Concluído em: ${new Date().toLocaleString('pt-BR')}`);
+        // Performance
+        const filesPerSecond = this.buildMetrics.compiledFiles / (this.buildMetrics.duration / 1000);
+        console.log(`⚡ Performance: ${filesPerSecond.toFixed(1)} arquivos/segundo`);
+        // Status de erros e warnings
+        if (this.buildMetrics.errors.length > 0) {
+            console.log(`❌ Erros: ${this.buildMetrics.errors.length}`);
+            this.buildMetrics.errors.forEach((error) => {
+                console.log(`   • ${error}`);
+            });
+        }
+        if (this.buildMetrics.warnings.length > 0) {
+            console.log(`⚠️  Warnings: ${this.buildMetrics.warnings.length}`);
+            this.buildMetrics.warnings.forEach((warning) => {
+                console.log(`   • ${warning}`);
+            });
+        }
+        if (this.buildMetrics.errors.length === 0 &&
+            this.buildMetrics.warnings.length === 0) {
+            console.log('✨ Build limpo: sem erros ou warnings');
+        }
+        console.log(`${line}\n`);
+        // Mostrar próximos passos se sucesso
+        if (this.buildMetrics.success) {
+            console.log('📋 PRÓXIMOS PASSOS:');
+            console.log('   • Pacote registrado no registro local');
+            console.log('   • Outros projetos detectarão automaticamente as mudanças');
+            console.log(`   • Use 'smart-override status' para verificar dependências`);
+            console.log(`   • Use 'smart-override remove' para voltar às versões do Azure\n`);
+        }
+    }
+    /**
+     * Registra um pacote após build e atualiza projetos dependentes
+     */
+    register() {
+        const packageJsonPath = path.join(process.cwd(), 'package.json');
+        if (!fs.existsSync(packageJsonPath)) {
+            console.log('❌ package.json não encontrado no diretório atual');
+            return;
+        }
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        const distPath = path.join(process.cwd(), 'dist');
+        // Exibir banner de início
+        this.showBuildStartBanner(packageJson.name, packageJson.version);
+        console.log('🔍 Verificando estrutura do projeto...');
+        if (!fs.existsSync(distPath)) {
+            console.log('❌ Pasta dist não encontrada');
+            console.log('💡 Execute o build do TypeScript primeiro: npm run build ou tsc');
+            this.buildMetrics.errors.push('Pasta dist não encontrada');
+            this.showBuildSummary(packageJson.name, packageJson.version);
+            return;
+        }
+        // Coletar métricas do build
+        console.log('📊 Coletando métricas do build...');
+        this.buildMetrics.compiledFiles = this.countCompiledFiles(distPath);
+        const distSize = this.calculateDirectorySize(distPath);
+        this.buildMetrics.buildSize = this.formatSize(distSize);
+        console.log(`   • Arquivos compilados: ${this.buildMetrics.compiledFiles}`);
+        console.log(`   • Tamanho do build: ${this.buildMetrics.buildSize}`);
+        // Verificar arquivos essenciais
+        console.log('🔎 Verificando arquivos essenciais...');
+        const essentialFiles = ['dist/index.js', 'dist/index.d.ts'];
+        const missingFiles = essentialFiles.filter((file) => !fs.existsSync(path.join(process.cwd(), file)));
+        if (missingFiles.length > 0) {
+            console.log(`⚠️  Arquivos essenciais ausentes: ${missingFiles.join(', ')}`);
+            this.buildMetrics.warnings.push(`Arquivos ausentes: ${missingFiles.join(', ')}`);
+        }
+        else {
+            console.log('✅ Todos os arquivos essenciais presentes');
+        }
+        // Registrar no registry local
+        console.log('📝 Registrando no registry local...');
+        const registry = this.getLocalRegistry();
+        const buildDetails = {
+            compiledFiles: this.buildMetrics.compiledFiles,
+            buildSize: this.buildMetrics.buildSize,
+            nodeVersion: process.version,
+            timestamp: new Date().toISOString(),
+        };
+        registry[packageJson.name] = {
+            name: packageJson.name,
+            version: packageJson.version,
+            path: process.cwd(),
+            lastBuild: Date.now(),
+            buildDuration: this.buildMetrics.duration,
+            buildDetails,
+        };
+        this.saveLocalRegistry(registry);
+        this.buildMetrics.success = true;
+        console.log('✅ Pacote registrado com sucesso');
+        // Registrar este projeto como "watchable" pelos outros
+        this.registerAsWatchableProject(packageJson.name);
+        // Verificar e notificar projetos dependentes
+        this.notifyDependentProjects(packageJson.name);
+        // Exibir resumo final
+        this.showBuildSummary(packageJson.name, packageJson.version);
+    }
+    /**
+     * Registra o projeto atual como um que pode ser "observado" por outros
+     */
+    registerAsWatchableProject(packageName) {
+        const watchRegistry = this.getWatchRegistry();
+        const packageJsonPath = path.join(process.cwd(), 'package.json');
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        const dependencies = {
+            ...packageJson.dependencies,
+            ...packageJson.devDependencies,
+        };
+        watchRegistry[packageName] = {
+            name: packageName,
+            path: process.cwd(),
+            lastChecked: Date.now(),
+            dependencies: Object.keys(dependencies)
+                .filter((dep) => isScopedPackage(dep))
+                .reduce((acc, dep) => {
+                acc[dep] = dependencies[dep];
+                return acc;
+            }, {}),
+        };
+        this.saveWatchRegistry(watchRegistry);
+    }
+    /**
+     * Notifica e atualiza automaticamente projetos que dependem do pacote atual
+     */
+    notifyDependentProjects(packageName) {
+        console.log('🔗 Verificando projetos dependentes para atualização automática...');
+        const watchRegistry = this.getWatchRegistry();
+        const localRegistry = this.getLocalRegistry();
+        const currentPackage = localRegistry[packageName];
+        if (!currentPackage)
+            return;
+        let updatedProjects = 0;
+        // Percorrer todos os projetos registrados
+        Object.values(watchRegistry).forEach((watchedProject) => {
+            if (watchedProject.name === packageName)
+                return; // Pular o próprio projeto
+            // Verificar se este projeto depende do pacote que acabou de ser buildado
+            if (watchedProject.dependencies[packageName]) {
+                const requiredVersion = watchedProject.dependencies[packageName].replace(/[\^~]/, '');
+                const versionComparison = this.compareVersions(currentPackage.version, requiredVersion);
+                if (versionComparison >= 0) {
+                    console.log(`   🎯 Atualizando ${watchedProject.name}...`);
+                    // Aplicar override no projeto dependente
+                    if (this.applyOverrideToProject(watchedProject, packageName, currentPackage)) {
+                        updatedProjects++;
+                        console.log(`      ✅ ${watchedProject.name} atualizado com ${packageName}@${currentPackage.version}`);
+                    }
+                    else {
+                        console.log(`      ℹ️  ${watchedProject.name} já está atualizado`);
+                    }
+                }
+                else {
+                    console.log(`   ⚠️  ${watchedProject.name} requer v${requiredVersion}, mas local é v${currentPackage.version}`);
+                }
+            }
+        });
+        if (updatedProjects > 0) {
+            console.log(`\n🎉 ${updatedProjects} projeto(s) atualizado(s) automaticamente!`);
+            console.log('💡 Os projetos atualizados agora usam sua versão local mais recente');
+        }
+        else {
+            console.log('   • Nenhum projeto dependente precisou de atualização');
+        }
+    }
+    /**
+     * Aplica override em um projeto específico
+     */
+    applyOverrideToProject(watchedProject, packageName, localPkg) {
+        const nodeModulesPath = path.join(watchedProject.path, 'node_modules', packageName);
+        // Verificar se o projeto ainda existe
+        if (!fs.existsSync(watchedProject.path))
+            return false;
+        // Verificar se já está aplicado e é a mesma versão
+        const overrideMarker = path.join(nodeModulesPath, '.local-override.json');
+        if (fs.existsSync(overrideMarker)) {
+            try {
+                const existing = JSON.parse(fs.readFileSync(overrideMarker, 'utf8'));
+                if (existing.lastBuild >= localPkg.lastBuild) {
+                    return false; // Já está atualizado
+                }
+            }
+            catch { }
+        }
+        try {
+            // Remove versão atual do node_modules
+            if (fs.existsSync(nodeModulesPath)) {
+                if (process.platform === 'win32') {
+                    execSync(`rmdir /s /q "${nodeModulesPath}"`, {
+                        stdio: 'pipe',
+                        timeout: 10_000,
+                    });
+                }
+                else {
+                    execSync(`rm -rf "${nodeModulesPath}"`, {
+                        stdio: 'pipe',
+                        timeout: 10_000,
+                    });
+                }
+            }
+            // Cria diretório
+            fs.mkdirSync(nodeModulesPath, { recursive: true });
+            // Copia arquivos essenciais
+            this.copyFiles(localPkg.path, nodeModulesPath);
+            // Marca como override
+            fs.writeFileSync(overrideMarker, JSON.stringify({
+                source: localPkg.path,
+                version: localPkg.version,
+                lastBuild: localPkg.lastBuild,
+                appliedAt: Date.now(),
+                buildDetails: localPkg.buildDetails,
+                autoApplied: true, // Marca que foi aplicado automaticamente
+            }, null, 2));
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Verifica e aplica overrides locais (versão melhorada)
+     */
+    check() {
+        const packageJsonPath = path.join(process.cwd(), 'package.json');
+        if (!fs.existsSync(packageJsonPath)) {
+            console.log('❌ package.json não encontrado');
+            return;
+        }
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        const dependencies = {
+            ...packageJson.dependencies,
+            ...packageJson.devDependencies,
+        };
+        const registry = this.getLocalRegistry();
+        console.log('\n🔍 Verificando dependências locais...');
+        console.log(`📦 Projeto: ${packageJson.name}@${packageJson.version}`);
+        const scopedDeps = Object.keys(dependencies).filter((dep) => isScopedPackage(dep));
+        if (scopedDeps.length === 0) {
+            console.log('ℹ️  Nenhuma dependência scoped (@) encontrada');
+            return;
+        }
+        console.log(`🎯 Dependências scoped encontradas: ${scopedDeps.length}`);
+        // 🆕 ATUALIZAR O REGISTRY LOCAL COM AS VERSÕES DO PACKAGE.JSON
+        console.log('\n🔄 Atualizando registry local com versões do package.json...');
+        let updatedRegistry = false;
+        scopedDeps.forEach((depName) => {
+            const requiredVersion = dependencies[depName].replace(/[\^~]/, '');
+            // Se o pacote não existe no registry local, tentar encontrá-lo
+            if (!registry[depName]) {
+                // Procurar pelo pacote nos node_modules
+                const nodeModulesPath = path.join(process.cwd(), 'node_modules', depName);
+                if (fs.existsSync(nodeModulesPath)) {
+                    const depPackageJson = path.join(nodeModulesPath, 'package.json');
+                    if (fs.existsSync(depPackageJson)) {
+                        try {
+                            const depPkg = JSON.parse(fs.readFileSync(depPackageJson, 'utf8'));
+                            // Adicionar ao registry local
+                            registry[depName] = {
+                                name: depName,
+                                version: depPkg.version,
+                                path: nodeModulesPath,
+                                lastBuild: Date.now(),
+                                buildDetails: {
+                                    timestamp: new Date().toISOString(),
+                                    nodeVersion: process.version,
+                                },
+                            };
+                            updatedRegistry = true;
+                            console.log(`   ✅ Adicionado ao registry: ${depName}@${depPkg.version}`);
+                        }
+                        catch (parseError) {
+                            console.log(`   ⚠️  Erro ao ler package.json de ${depName} (arquivo corrompido ou com conflitos de merge)`);
+                        }
+                    }
+                }
+            }
+            else {
+                // Atualizar versão se diferente
+                const currentVersion = registry[depName].version;
+                if (currentVersion !== requiredVersion) {
+                    const nodeModulesPath = path.join(process.cwd(), 'node_modules', depName);
+                    if (fs.existsSync(nodeModulesPath)) {
+                        const depPackageJson = path.join(nodeModulesPath, 'package.json');
+                        if (fs.existsSync(depPackageJson)) {
+                            try {
+                                const depPkg = JSON.parse(fs.readFileSync(depPackageJson, 'utf8'));
+                                registry[depName].version = depPkg.version;
+                                registry[depName].lastBuild = Date.now();
+                                updatedRegistry = true;
+                                console.log(`   🔄 Atualizado: ${depName} v${currentVersion} → v${depPkg.version}`);
+                            }
+                            catch (parseError) {
+                                console.log(`   ⚠️  Erro ao ler package.json de ${depName} (arquivo corrompido ou com conflitos de merge)`);
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        // Salvar registry atualizado
+        if (updatedRegistry) {
+            fs.writeFileSync(LOCAL_REGISTRY, JSON.stringify(registry, null, 2));
+            console.log('✅ Registry local atualizado');
+        }
+        let appliedCount = 0;
+        let skippedCount = 0;
+        let alreadyInstalledCount = 0;
+        console.log('\n📦 Sincronizando dependências scoped (@)...');
+        console.log('   🔒 Framework (@silasfmartins/testhub): sempre do Azure DevOps');
+        console.log('   📦 Outros pacotes (@rbqa/*, @sfa/*, etc.): versão local prevalece sobre Azure\n');
+        for (const depName of scopedDeps) {
+            const requiredVersionRaw = dependencies[depName];
+            const requiredVersion = requiredVersionRaw.replace(/[\^~]/, '');
+            console.log(`\n   📋 ${depName}`);
+            console.log(`      📄 Versão no package.json: ${requiredVersionRaw}`);
+            // Verificar versão instalada atualmente
+            const nodeModulesPath = path.join(process.cwd(), 'node_modules', depName);
+            let installedVersion = null;
+            let hasLocalOverride = false;
+            if (fs.existsSync(nodeModulesPath)) {
+                const depPkgPath = path.join(nodeModulesPath, 'package.json');
+                const overrideMarker = path.join(nodeModulesPath, '.local-override.json');
+                if (fs.existsSync(depPkgPath)) {
+                    try {
+                        const depPkg = JSON.parse(fs.readFileSync(depPkgPath, 'utf8'));
+                        installedVersion = depPkg.version;
+                    }
+                    catch (parseError) {
+                        console.log(`      ⚠️  Erro ao ler package.json (arquivo corrompido ou com conflitos de merge)`);
+                        console.log(`      💡 Tente: rm -rf node_modules/${depName} && npm install`);
+                    }
+                }
+                hasLocalOverride = fs.existsSync(overrideMarker);
+            }
+            if (installedVersion) {
+                console.log(`      📦 Versão instalada: ${installedVersion}${hasLocalOverride ? ' (LOCAL)' : ' (AZURE)'}`);
+            }
+            // 🔒 FRAMEWORK (@silasfmartins/testhub): SEMPRE instalar do Azure DevOps
+            if (PREFER_AZURE_PACKAGES.has(depName)) {
+                console.log(`      🔒 FRAMEWORK: garantindo instalação do Azure DevOps`);
+                // Verificar se já está na versão correta (do Azure, sem override local)
+                if (installedVersion && !hasLocalOverride) {
+                    const versionMatch = this.compareVersions(installedVersion, requiredVersion) >= 0;
+                    if (versionMatch) {
+                        console.log(`      ✅ Framework já está na versão correta (${installedVersion})`);
+                        alreadyInstalledCount++;
+                        continue;
+                    }
+                }
+                // Remover override local se existir (framework SEMPRE vem do Azure)
+                if (hasLocalOverride) {
+                    console.log(`      🗑️  Removendo override local (framework deve vir do Azure)...`);
+                    try {
+                        if (process.platform === 'win32') {
+                            execSync(`rmdir /s /q "${nodeModulesPath}"`, { stdio: 'pipe', timeout: 10000 });
+                        }
+                        else {
+                            execSync(`rm -rf "${nodeModulesPath}"`, { stdio: 'pipe', timeout: 10000 });
+                        }
+                    }
+                    catch (e) {
+                        // Ignorar erro de remoção
+                    }
+                }
+                // Instalar a versão do package.json do Azure
+                console.log(`      🔄 Instalando ${depName}@${requiredVersion} do Azure DevOps...`);
+                if (this.installFromAzure(depName, requiredVersion)) {
+                    appliedCount++;
+                    console.log(`      ✅ Framework instalado com sucesso: ${depName}@${requiredVersion}`);
+                }
+                else {
+                    skippedCount++;
+                    console.log(`      ❌ Falha ao instalar framework do Azure`);
+                    console.log(`      💡 Verifique sua conexão com o Azure DevOps`);
+                }
+                continue;
+            }
+            // 📦 OUTROS PACOTES SCOPED (@rbqa/*, @sfa/*, etc.): versão LOCAL prevalece sobre Azure
+            // Verificar se tem versão local disponível no registry
+            const localPkg = registry[depName];
+            if (localPkg) {
+                // Tem versão local disponível
+                console.log(`      🔗 Versão local disponível: ${localPkg.version}`);
+                // Verificar se a versão local atende ao requisito
+                const localMeetsRequirement = this.compareVersions(localPkg.version, requiredVersion) >= 0;
+                if (localMeetsRequirement) {
+                    // Versão local atende - usar LOCAL (prevalece sobre Azure)
+                    if (hasLocalOverride && installedVersion === localPkg.version) {
+                        console.log(`      ✅ Versão local já está aplicada (${localPkg.version})`);
+                        alreadyInstalledCount++;
+                    }
+                    else {
+                        console.log(`      🔗 Aplicando versão LOCAL (prevalece sobre Azure)...`);
+                        if (this.applyOverride(depName, localPkg)) {
+                            appliedCount++;
+                            console.log(`      ✅ Versão local aplicada: ${depName}@${localPkg.version}`);
+                        }
+                        else {
+                            alreadyInstalledCount++;
+                            console.log(`      ✅ Versão local já está atualizada`);
+                        }
+                    }
+                }
+                else {
+                    // Versão local não atende - verificar Azure
+                    console.log(`      ⚠️  Versão local (${localPkg.version}) não atende requisito (${requiredVersion})`);
+                    const existsInAzure = this.checkIfExistsInAzure(depName);
+                    if (existsInAzure) {
+                        console.log(`      🔄 Instalando ${depName}@${requiredVersion} do Azure DevOps...`);
+                        if (this.installFromAzure(depName, requiredVersion)) {
+                            appliedCount++;
+                            console.log(`      ✅ Instalado do Azure: ${depName}@${requiredVersion}`);
+                        }
+                        else {
+                            skippedCount++;
+                            console.log(`      ❌ Falha ao instalar do Azure`);
+                        }
+                    }
+                    else {
+                        skippedCount++;
+                        console.log(`      ❌ Versão não disponível (nem local, nem Azure)`);
+                    }
+                }
+            }
+            else {
+                // Não tem versão local - verificar se já está instalado ou buscar no Azure
+                if (installedVersion) {
+                    const installedMeetsRequirement = this.compareVersions(installedVersion, requiredVersion) >= 0;
+                    if (installedMeetsRequirement) {
+                        console.log(`      ✅ Já está instalado na versão correta (${installedVersion})`);
+                        alreadyInstalledCount++;
+                        continue;
+                    }
+                }
+                // Buscar no Azure
+                const existsInAzure = this.checkIfExistsInAzure(depName);
+                if (existsInAzure) {
+                    console.log(`      ☁️  Instalando ${depName}@${requiredVersion} do Azure DevOps...`);
+                    if (this.installFromAzure(depName, requiredVersion)) {
+                        appliedCount++;
+                        console.log(`      ✅ Instalado do Azure: ${depName}@${requiredVersion}`);
+                    }
+                    else {
+                        skippedCount++;
+                        console.log(`      ❌ Falha ao instalar do Azure`);
+                    }
+                }
+                else {
+                    if (installedVersion) {
+                        console.log(`      ℹ️  Mantendo versão instalada: ${installedVersion}`);
+                        alreadyInstalledCount++;
+                    }
+                    else {
+                        skippedCount++;
+                        console.log(`      ❌ Pacote não encontrado (nem local, nem Azure)`);
+                        console.log(`      💡 Execute 'npm run build' no projeto da dependência`);
+                    }
+                }
+            }
+        }
+        // Registrar este projeto para futuras atualizações automáticas
+        this.registerAsWatchableProject(packageJson.name);
+        // Resumo final
+        console.log('\n' + '═'.repeat(60));
+        console.log('📊 RESUMO DA SINCRONIZAÇÃO:');
+        console.log(`   ✅ Sincronizados: ${appliedCount}`);
+        console.log(`   ✔️  Já na versão correta: ${alreadyInstalledCount}`);
+        console.log(`   ❌ Falhas: ${skippedCount}`);
+        console.log(`   📦 Total de dependências scoped: ${scopedDeps.length}`);
+        if (appliedCount > 0) {
+            console.log(`\n🎯 ${appliedCount} pacote(s) sincronizado(s)`);
+        }
+        if (alreadyInstalledCount > 0) {
+            console.log(`✅ ${alreadyInstalledCount} pacote(s) já estavam corretos`);
+        }
+        if (skippedCount > 0) {
+            console.log(`\n⚠️  ${skippedCount} pacote(s) com problema`);
+            console.log('   💡 Verifique sua conexão com o Azure DevOps');
+            console.log('   💡 Tente: npm cache clean --force && npm install');
+        }
+        if (appliedCount === 0 && skippedCount === 0) {
+            console.log('\n✨ Todas as dependências já estão sincronizadas!');
+        }
+        console.log('═'.repeat(60));
+    }
+    /**
+     * 🔍 Verifica se um pacote existe no Azure DevOps (sem falhar o build)
+     */
+    checkIfExistsInAzure(packageName) {
+        try {
+            // Tentar verificar se o pacote existe no registry do Azure
+            const result = execSync(`npm view ${packageName} version`, {
+                stdio: 'pipe',
+                timeout: 10000,
+            });
+            return result.toString().trim().length > 0;
+        }
+        catch (error) {
+            // Se der erro 404 ou timeout, assume que não existe
+            return false;
+        }
+    }
+    /**
+     * 🔍 Obtém a versão mais recente disponível no Azure DevOps
+     */
+    getLatestAzureVersion(packageName) {
+        try {
+            const result = execSync(`npm view ${packageName} version`, {
+                stdio: 'pipe',
+                timeout: 15000,
+            });
+            return result.toString().trim() || null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * 🔧 Instala um pacote do Azure DevOps
+     */
+    installFromAzure(packageName, version) {
+        const versionSpec = version ? `${packageName}@${version}` : `${packageName}@latest`;
+        try {
+            // 🔧 Usar --ignore-scripts para evitar erros de postinstall em sub-dependências
+            // Também usar --prefer-online para garantir que busca a versão correta do Azure
+            console.log(`      ℹ️  Instalando com --ignore-scripts para evitar conflitos...`);
+            execSync(`npm install ${versionSpec} --prefer-online --ignore-scripts`, {
+                stdio: 'inherit',
+                cwd: process.cwd(),
+                timeout: 180000, // 3 minutos de timeout
+            });
+            return true;
+        }
+        catch (error) {
+            // Tentar com --force e --ignore-scripts se falhou
+            console.log(`      🔄 Tentando com --force --ignore-scripts...`);
+            try {
+                execSync(`npm install ${versionSpec} --force --ignore-scripts`, {
+                    stdio: 'inherit',
+                    cwd: process.cwd(),
+                    timeout: 180000,
+                });
+                return true;
+            }
+            catch (retryError) {
+                console.error(`      ❌ Falha ao instalar ${versionSpec}`);
+                console.log(`      💡 Tente manualmente: npm install ${versionSpec} --force --ignore-scripts`);
+                return false;
+            }
+        }
+    }
+    compareVersions(v1, v2) {
+        const parts1 = v1.split('.').map(Number);
+        const parts2 = v2.split('.').map(Number);
+        for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+            const a = parts1[i] || 0;
+            const b = parts2[i] || 0;
+            if (a > b)
+                return 1;
+            if (a < b)
+                return -1;
+        }
+        return 0;
+    }
+    applyOverride(packageName, localPkg) {
+        const nodeModulesPath = path.join(process.cwd(), 'node_modules', packageName);
+        // Verificar se o local ainda existe e é mais recente
+        if (!fs.existsSync(localPkg.path))
+            return false;
+        const localDistPath = path.join(localPkg.path, 'dist');
+        if (!fs.existsSync(localDistPath))
+            return false;
+        // Verificar se já está aplicado e é a mesma versão
+        const overrideMarker = path.join(nodeModulesPath, '.local-override.json');
+        if (fs.existsSync(overrideMarker)) {
+            const existing = JSON.parse(fs.readFileSync(overrideMarker, 'utf8'));
+            if (existing.lastBuild >= localPkg.lastBuild) {
+                return false; // Já está atualizado
+            }
+        }
+        try {
+            // Remove versão atual do node_modules
+            if (fs.existsSync(nodeModulesPath)) {
+                if (process.platform === 'win32') {
+                    execSync(`rmdir /s /q "${nodeModulesPath}"`, {
+                        stdio: 'pipe',
+                        timeout: 10_000,
+                    });
+                }
+                else {
+                    execSync(`rm -rf "${nodeModulesPath}"`, {
+                        stdio: 'pipe',
+                        timeout: 10_000,
+                    });
+                }
+            }
+            // Cria diretório
+            fs.mkdirSync(nodeModulesPath, { recursive: true });
+            // Copia arquivos essenciais
+            this.copyFiles(localPkg.path, nodeModulesPath);
+            // Marca como override
+            fs.writeFileSync(overrideMarker, JSON.stringify({
+                source: localPkg.path,
+                version: localPkg.version,
+                lastBuild: localPkg.lastBuild,
+                appliedAt: Date.now(),
+                buildDetails: localPkg.buildDetails,
+            }, null, 2));
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    copyFiles(source, destination) {
+        // Copiar arquivos essenciais
+        const filesToCopy = ['package.json', 'README.md'];
+        const dirsToCopy = ['dist'];
+        filesToCopy.forEach((file) => {
+            const srcFile = path.join(source, file);
+            const destFile = path.join(destination, file);
+            if (fs.existsSync(srcFile)) {
+                fs.copyFileSync(srcFile, destFile);
+            }
+        });
+        dirsToCopy.forEach((dir) => {
+            const srcDir = path.join(source, dir);
+            const destDir = path.join(destination, dir);
+            if (fs.existsSync(srcDir)) {
+                try {
+                    if (process.platform === 'win32') {
+                        execSync(`xcopy "${srcDir}" "${destDir}" /E /I /Y /Q`, {
+                            stdio: 'pipe',
+                            timeout: 15_000,
+                        });
+                    }
+                    else {
+                        execSync(`cp -r "${srcDir}" "${destDir}"`, {
+                            stdio: 'pipe',
+                            timeout: 15_000,
+                        });
+                    }
+                }
+                catch (error) {
+                    console.warn(`Aviso: Erro ao copiar diretório ${dir}`);
+                }
+            }
+        });
+    }
+    /**
+     * Remove todos os overrides locais (versão melhorada com suporte a pacotes locais)
+     */
+    remove() {
+        console.log('\n🔄 Removendo overrides locais...');
+        const nodeModulesPath = path.join(process.cwd(), 'node_modules');
+        if (!fs.existsSync(nodeModulesPath)) {
+            console.log('📂 Diretório node_modules não encontrado');
+            return;
+        }
+        const packages = fs
+            .readdirSync(nodeModulesPath)
+            .filter((dir) => dir.startsWith('@'))
+            .filter((dir) => fs.existsSync(path.join(nodeModulesPath, dir, '.local-override.json')));
+        if (packages.length === 0) {
+            console.log('ℹ️ Nenhum override local encontrado');
+            return;
+        }
+        console.log(`🎯 Encontrados ${packages.length} override(s) para remover:`);
+        const startTime = Date.now();
+        let removedCount = 0;
+        const localOnlyPackages = [];
+        // Verificar quais pacotes existem apenas localmente
+        console.log('\n🔍 Verificando disponibilidade no Azure DevOps...');
+        packages.forEach((pkg) => {
+            if (this.checkIfExistsInAzure(pkg)) {
+                console.log(`   ✅ ${pkg} - Disponível no Azure`);
+            }
+            else {
+                localOnlyPackages.push(pkg);
+                console.log(`   💡 ${pkg} - Existe APENAS localmente`);
+            }
+        });
+        if (localOnlyPackages.length > 0) {
+            console.log(`\n⚠️  ATENÇÃO: ${localOnlyPackages.length} pacote(s) existe(m) APENAS localmente:`);
+            localOnlyPackages.forEach((pkg) => {
+                console.log(`   • ${pkg}`);
+            });
+            console.log('\n❌ Não é possível remover overrides desses pacotes!');
+            console.log('💡 Esses pacotes não estão publicados no Azure DevOps.');
+            console.log('💡 Mantenha os overrides locais ou publique-os no Azure primeiro.');
+            // Filtrar apenas pacotes que podem ser removidos
+            const packagesToRemove = packages.filter((pkg) => !localOnlyPackages.includes(pkg));
+            if (packagesToRemove.length === 0) {
+                console.log('\n📦 Nenhum pacote pode ser removido (todos são apenas locais).');
+                console.log('═'.repeat(60));
+                return;
+            }
+            console.log(`\n🔄 Removendo apenas pacotes disponíveis no Azure (${packagesToRemove.length})...`);
+        }
+        else {
+            const packagesToRemove = packages;
+        }
+        const packagesToRemove = packages.filter((pkg) => !localOnlyPackages.includes(pkg));
+        packagesToRemove.forEach((pkg) => {
+            const pkgPath = path.join(nodeModulesPath, pkg);
+            console.log(`   🗑️ Removendo ${pkg}...`);
+            try {
+                if (process.platform === 'win32') {
+                    execSync(`rmdir /s /q "${pkgPath}"`, { stdio: 'pipe', timeout: 5000 });
+                }
+                else {
+                    execSync(`rm -rf "${pkgPath}"`, { stdio: 'pipe', timeout: 5000 });
+                }
+                removedCount++;
+                console.log('      ✅ Removido com sucesso');
+            }
+            catch (error) {
+                console.log(`      ⚠️ Erro ao remover: ${pkg}`);
+            }
+        });
+        if (removedCount > 0) {
+            console.log(`\n📦 Reinstalando ${removedCount} dependência(s) do Azure DevOps...`);
+            const installStart = Date.now();
+            try {
+                // Instalar apenas os pacotes que foram removidos (que existem no Azure)
+                const packagesToInstall = packagesToRemove.join(' ');
+                execSync(`npm install ${packagesToInstall} --force`, {
+                    stdio: 'inherit',
+                });
+                const installTime = Date.now() - installStart;
+                console.log('\n✅ Processo concluído com sucesso!');
+                console.log('📊 Resumo:');
+                console.log(`   • Overrides removidos: ${removedCount}`);
+                console.log(`   • Mantidos (apenas local): ${localOnlyPackages.length}`);
+                console.log(`   • Tempo de remoção: ${this.formatDuration(Date.now() - startTime)}`);
+                console.log(`   • Tempo de reinstalação: ${this.formatDuration(installTime)}`);
+                console.log('   • Pacotes do Azure reinstalados com sucesso');
+                if (localOnlyPackages.length > 0) {
+                    console.log('\n💡 Pacotes mantidos localmente:');
+                    localOnlyPackages.forEach((pkg) => {
+                        console.log(`   • ${pkg} - Não disponível no Azure`);
+                    });
+                }
+            }
+            catch (error) {
+                console.log(`❌ Erro durante reinstalação: ${error}`);
+                console.log('💡 Alguns pacotes podem não existir no Azure DevOps.');
+                console.log(`   Execute 'npm install' manualmente para resolver.`);
+            }
+        }
+        else {
+            console.log('\n⚠️  Nenhum pacote foi removido.');
+            console.log('📦 Todos os pacotes com override existem apenas localmente.');
+        }
+        console.log('═'.repeat(60));
+    }
+    /**
+     * Mostra status dos overrides (versão melhorada)
+     */
+    status() {
+        console.log('\n📊 STATUS DAS DEPENDÊNCIAS SCOPED (@):');
+        console.log('═'.repeat(70));
+        const nodeModulesPath = path.join(process.cwd(), 'node_modules');
+        if (!fs.existsSync(nodeModulesPath)) {
+            console.log('📂 Diretório node_modules não encontrado');
+            return;
+        }
+        const packages = fs
+            .readdirSync(nodeModulesPath)
+            .filter((dir) => dir.startsWith('@'));
+        if (packages.length === 0) {
+            console.log('📦 Nenhuma dependência scoped (@) encontrada');
+            return;
+        }
+        let localCount = 0;
+        let azureCount = 0;
+        let autoUpdatedCount = 0;
+        packages.forEach((pkg) => {
+            const pkgPath = path.join(nodeModulesPath, pkg);
+            const overrideFile = path.join(pkgPath, '.local-override.json');
+            if (fs.existsSync(overrideFile)) {
+                localCount++;
+                try {
+                    const override = JSON.parse(fs.readFileSync(overrideFile, 'utf8'));
+                    const age = Math.round((Date.now() - override.appliedAt) / 1000 / 60);
+                    const autoApplied = override.autoApplied ? ' (AUTO)' : '';
+                    if (override.autoApplied)
+                        autoUpdatedCount++;
+                    console.log(`🔗 ${pkg}@${override.version} (LOCAL${autoApplied})`);
+                    console.log(`   📅 Aplicado há ${age} minuto(s)`);
+                    if (override.buildDetails) {
+                        console.log(`   📊 Build: ${override.buildDetails.buildSize}, ${override.buildDetails.compiledFiles} arquivos`);
+                        console.log(`   🕐 Compilado: ${new Date(override.buildDetails.timestamp).toLocaleString('pt-BR')}`);
+                    }
+                    console.log(`   📂 Origem: ${override.source}`);
+                    if (override.autoApplied) {
+                        console.log('   🤖 Atualização automática ativada');
+                    }
+                }
+                catch {
+                    console.log(`🔗 ${pkg} (LOCAL - erro ao ler detalhes)`);
+                }
+                console.log('');
+            }
+            else {
+                azureCount++;
+                const packageJsonPath = path.join(pkgPath, 'package.json');
+                if (fs.existsSync(packageJsonPath)) {
+                    try {
+                        const pkgJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+                        console.log(`☁️ ${pkg}@${pkgJson.version} (AZURE DEVOPS)`);
+                    }
+                    catch {
+                        console.log(`☁️ ${pkg} (AZURE DEVOPS - erro ao ler versão)`);
+                    }
+                }
+            }
+        });
+        console.log('═'.repeat(70));
+        console.log('📋 RESUMO:');
+        console.log(`   🔗 Dependências locais: ${localCount}`);
+        console.log(`   🤖 Atualizações automáticas: ${autoUpdatedCount}`);
+        console.log(`   ☁️ Dependências Azure: ${azureCount}`);
+        console.log(`   📦 Total: ${packages.length}`);
+        if (localCount > 0) {
+            console.log('\n💡 DICAS:');
+            console.log(`   • Use 'smart-override remove' para voltar às versões do Azure`);
+            console.log('   • Dependências com (AUTO) são atualizadas automaticamente');
+            console.log('   • Builds locais têm prioridade sobre versões do registry');
+        }
+        console.log('═'.repeat(70));
+    }
+    /**
+     * Atualiza o registry local com a versão atual do package.json
+     */
+    updateLocalRegistry() {
+        const packageJsonPath = path.join(process.cwd(), 'package.json');
+        if (!fs.existsSync(packageJsonPath)) {
+            console.log('⚠️  package.json não encontrado');
+            return;
+        }
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        const registry = this.getLocalRegistry();
+        // Verificar se é um pacote scoped (@org/nome)
+        if (!isScopedPackage(packageJson.name)) {
+            console.log('⚠️  Este não é um pacote scoped (@org/nome)');
+            return;
+        }
+        const distPath = path.join(process.cwd(), 'dist');
+        const hasDistFolder = fs.existsSync(distPath);
+        // Atualizar ou criar entrada no registry
+        const existingEntry = registry[packageJson.name];
+        registry[packageJson.name] = {
+            name: packageJson.name,
+            version: packageJson.version,
+            path: process.cwd(),
+            lastBuild: existingEntry?.lastBuild || Date.now(),
+            buildDuration: existingEntry?.buildDuration,
+            buildDetails: existingEntry?.buildDetails || {
+                compiledFiles: hasDistFolder ? this.countCompiledFiles(distPath) : 0,
+                buildSize: hasDistFolder
+                    ? this.formatSize(this.calculateDirectorySize(distPath))
+                    : '0 KB',
+                nodeVersion: process.version,
+                timestamp: new Date().toISOString(),
+            },
+        };
+        this.saveLocalRegistry(registry);
+        console.log(`✅ Registry local atualizado: ${packageJson.name}@${packageJson.version}`);
+    }
+    /**
+     * Comando para sincronizar manualmente todos os projetos
+     * Agora também instala do Azure DevOps quando necessário
+     */
+    sync() {
+        console.log('\n🔄 SINCRONIZAÇÃO MANUAL DE PROJETOS:');
+        console.log('═'.repeat(70));
+        // Primeiro, atualizar o registry local com a versão atual
+        this.updateLocalRegistry();
+        console.log(); // linha em branco
+        // Verificar dependências do projeto ATUAL primeiro
+        const packageJsonPath = path.join(process.cwd(), 'package.json');
+        if (fs.existsSync(packageJsonPath)) {
+            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+            const dependencies = {
+                ...packageJson.dependencies,
+                ...packageJson.devDependencies,
+            };
+            const scopedDeps = Object.keys(dependencies).filter((dep) => isScopedPackage(dep));
+            if (scopedDeps.length > 0) {
+                console.log(`📦 Sincronizando dependências do projeto atual: ${packageJson.name}`);
+                console.log(`🎯 Dependências scoped encontradas: ${scopedDeps.length}`);
+                console.log();
+                let installedFromAzure = 0;
+                let localApplied = 0;
+                let upToDate = 0;
+                let failed = 0;
+                const localRegistry = this.getLocalRegistry();
+                for (const depName of scopedDeps) {
+                    const requiredVersion = dependencies[depName].replace(/[\^~]/, '');
+                    console.log(`\n   📋 ${depName}@${requiredVersion}`);
+                    // Verificar versão instalada atualmente
+                    const nodeModulesPath = path.join(process.cwd(), 'node_modules', depName);
+                    let installedVersion = null;
+                    let hasLocalOverride = false;
+                    if (fs.existsSync(nodeModulesPath)) {
+                        const depPkgPath = path.join(nodeModulesPath, 'package.json');
+                        const overrideMarker = path.join(nodeModulesPath, '.local-override.json');
+                        if (fs.existsSync(depPkgPath)) {
+                            try {
+                                const depPkg = JSON.parse(fs.readFileSync(depPkgPath, 'utf8'));
+                                installedVersion = depPkg.version;
+                            }
+                            catch (parseError) {
+                                console.log(`      ⚠️  Erro ao ler package.json (arquivo corrompido ou com conflitos de merge)`);
+                                console.log(`      💡 Tente: rm -rf node_modules/${depName} && npm install`);
+                            }
+                        }
+                        hasLocalOverride = fs.existsSync(overrideMarker);
+                    }
+                    // Verificar se o pacote prefere Azure
+                    const prefersAzure = PREFER_AZURE_PACKAGES.has(depName);
+                    // Obter versão mais recente do Azure
+                    console.log(`      🔍 Verificando Azure DevOps...`);
+                    const azureVersion = this.getLatestAzureVersion(depName);
+                    if (azureVersion) {
+                        console.log(`      ☁️  Versão Azure: ${azureVersion}`);
+                        if (installedVersion) {
+                            console.log(`      📦 Versão instalada: ${installedVersion}${hasLocalOverride ? ' (LOCAL)' : ''}`);
+                        }
+                        // Comparar versões
+                        const azureIsNewer = installedVersion
+                            ? this.compareVersions(azureVersion, installedVersion) > 0
+                            : true;
+                        const azureMatchesRequired = this.compareVersions(azureVersion, requiredVersion) >= 0;
+                        // Lógica de decisão
+                        if (prefersAzure || azureIsNewer) {
+                            if (azureMatchesRequired) {
+                                if (!installedVersion || azureIsNewer) {
+                                    console.log(`      ⬆️  Nova versão disponível no Azure!`);
+                                    // Remover override local se existir
+                                    if (hasLocalOverride) {
+                                        console.log(`      🗑️  Removendo override local...`);
+                                        try {
+                                            if (process.platform === 'win32') {
+                                                execSync(`rmdir /s /q "${nodeModulesPath}"`, { stdio: 'pipe', timeout: 10000 });
+                                            }
+                                            else {
+                                                execSync(`rm -rf "${nodeModulesPath}"`, { stdio: 'pipe', timeout: 10000 });
+                                            }
+                                        }
+                                        catch (e) {
+                                            // Ignorar erro de remoção
+                                        }
+                                    }
+                                    // Instalar do Azure
+                                    if (this.installFromAzure(depName, azureVersion)) {
+                                        installedFromAzure++;
+                                    }
+                                    else {
+                                        failed++;
+                                    }
+                                }
+                                else {
+                                    console.log(`      ✅ Já está na versão mais recente do Azure`);
+                                    upToDate++;
+                                }
+                            }
+                            else {
+                                console.log(`      ⚠️  Versão Azure (${azureVersion}) não atende requisito (${requiredVersion})`);
+                                // Verificar se há versão local compatível
+                                if (localRegistry[depName]) {
+                                    const localPkg = localRegistry[depName];
+                                    if (this.compareVersions(localPkg.version, requiredVersion) >= 0) {
+                                        console.log(`      💡 Usando versão local: ${localPkg.version}`);
+                                        if (this.applyOverride(depName, localPkg)) {
+                                            localApplied++;
+                                        }
+                                        else {
+                                            upToDate++;
+                                        }
+                                    }
+                                    else {
+                                        console.log(`      ❌ Nenhuma versão compatível disponível`);
+                                        failed++;
+                                    }
+                                }
+                                else {
+                                    console.log(`      ❌ Nenhuma versão local disponível`);
+                                    failed++;
+                                }
+                            }
+                        }
+                        else if (!prefersAzure && localRegistry[depName]) {
+                            // Pacote não prefere Azure e tem versão local
+                            const localPkg = localRegistry[depName];
+                            const localVersion = localPkg.version;
+                            console.log(`      🔗 Versão local disponível: ${localVersion}`);
+                            if (this.compareVersions(localVersion, requiredVersion) >= 0) {
+                                if (this.applyOverride(depName, localPkg)) {
+                                    console.log(`      ✅ Override local aplicado`);
+                                    localApplied++;
+                                }
+                                else {
+                                    console.log(`      ℹ️  Override local já está atualizado`);
+                                    upToDate++;
+                                }
+                            }
+                            else {
+                                // Versão local desatualizada, instalar do Azure
+                                console.log(`      ⚠️  Versão local desatualizada, instalando do Azure...`);
+                                if (this.installFromAzure(depName, azureVersion)) {
+                                    installedFromAzure++;
+                                }
+                                else {
+                                    failed++;
+                                }
+                            }
+                        }
+                        else {
+                            // Não tem versão local e Azure está ok
+                            if (!installedVersion || azureIsNewer) {
+                                if (this.installFromAzure(depName, azureVersion)) {
+                                    installedFromAzure++;
+                                }
+                                else {
+                                    failed++;
+                                }
+                            }
+                            else {
+                                upToDate++;
+                            }
+                        }
+                    }
+                    else {
+                        console.log(`      ⚠️  Não encontrado no Azure DevOps`);
+                        // Tentar usar versão local
+                        if (localRegistry[depName]) {
+                            const localPkg = localRegistry[depName];
+                            console.log(`      💡 Usando versão local: ${localPkg.version}`);
+                            if (this.compareVersions(localPkg.version, requiredVersion) >= 0) {
+                                if (this.applyOverride(depName, localPkg)) {
+                                    localApplied++;
+                                }
+                                else {
+                                    upToDate++;
+                                }
+                            }
+                            else {
+                                console.log(`      ❌ Versão local incompatível`);
+                                failed++;
+                            }
+                        }
+                        else if (installedVersion) {
+                            console.log(`      ℹ️  Mantendo versão instalada: ${installedVersion}`);
+                            upToDate++;
+                        }
+                        else {
+                            console.log(`      ❌ Pacote não encontrado (nem Azure, nem local)`);
+                            failed++;
+                        }
+                    }
+                }
+                // Resumo do projeto atual
+                console.log('\n' + '═'.repeat(70));
+                console.log('📊 RESUMO DA SINCRONIZAÇÃO:');
+                console.log(`   ☁️  Instalados do Azure: ${installedFromAzure}`);
+                console.log(`   🔗 Overrides locais aplicados: ${localApplied}`);
+                console.log(`   ✅ Já atualizados: ${upToDate}`);
+                console.log(`   ❌ Falhas: ${failed}`);
+                console.log(`   📦 Total de dependências scoped: ${scopedDeps.length}`);
+                console.log(`   🕐 Concluído em: ${new Date().toLocaleString('pt-BR')}`);
+                if (failed > 0) {
+                    console.log('\n⚠️  AÇÕES RECOMENDADAS PARA FALHAS:');
+                    console.log('   1. Verifique sua conexão com o Azure DevOps');
+                    console.log('   2. Execute: npm cache clean --force');
+                    console.log('   3. Tente: npm install --force');
+                    console.log('   4. Verifique o arquivo .npmrc para configurações de registry');
+                }
+                if (installedFromAzure > 0) {
+                    console.log('\n✨ Pacotes atualizados do Azure DevOps com sucesso!');
+                }
+                console.log('═'.repeat(70));
+                return;
+            }
+        }
+        // Fallback: comportamento antigo para projetos registrados
+        const watchRegistry = this.getWatchRegistry();
+        const localRegistry = this.getLocalRegistry();
+        if (Object.keys(watchRegistry).length === 0) {
+            console.log('📂 Nenhum projeto registrado para sincronização');
+            console.log('💡 Execute npm run build em alguns projetos primeiro');
+            return;
+        }
+        console.log(`🎯 Projetos registrados: ${Object.keys(watchRegistry).length}`);
+        console.log(`📦 Pacotes locais disponíveis: ${Object.keys(localRegistry).length}`);
+        let totalUpdated = 0;
+        // Para cada projeto registrado
+        Object.values(watchRegistry).forEach((project) => {
+            console.log(`\n📋 Verificando ${project.name}...`);
+            let projectUpdated = 0;
+            // Para cada dependência scoped do projeto
+            Object.keys(project.dependencies).forEach((depName) => {
+                if (localRegistry[depName]) {
+                    const localPkg = localRegistry[depName];
+                    const requiredVersion = project.dependencies[depName].replace(/[\^~]/, '');
+                    const versionComparison = this.compareVersions(localPkg.version, requiredVersion);
+                    if (versionComparison >= 0) {
+                        if (this.applyOverrideToProject(project, depName, localPkg)) {
+                            console.log(`   ✅ ${depName}@${localPkg.version} aplicado`);
+                            projectUpdated++;
+                            totalUpdated++;
+                        }
+                        else {
+                            console.log(`   ℹ️  ${depName}@${localPkg.version} já atualizado`);
+                        }
+                    }
+                    else {
+                        console.log(`   ⚠️  ${depName}: local v${localPkg.version} < required v${requiredVersion}`);
+                    }
+                }
+            });
+            if (projectUpdated === 0) {
+                console.log('   📦 Nenhuma atualização necessária');
+            }
+        });
+        console.log('\n' + '═'.repeat(70));
+        console.log('📊 RESUMO DA SINCRONIZAÇÃO:');
+        console.log(`   🔄 Projetos verificados: ${Object.keys(watchRegistry).length}`);
+        console.log(`   ✅ Atualizações aplicadas: ${totalUpdated}`);
+        console.log(`   🕐 Concluído em: ${new Date().toLocaleString('pt-BR')}`);
+        console.log('═'.repeat(70));
+    }
+}
+// CLI
+const command = process.argv[2];
+const override = new SmartOverride();
+switch (command) {
+    case 'register':
+        override.register();
+        break;
+    case 'check':
+        override.check();
+        break;
+    case 'remove':
+        override.remove();
+        break;
+    case 'status':
+        override.status();
+        break;
+    case 'sync':
+        await (async () => {
+            await override.sync();
+            try {
+                // Atualizar package-lock.json imediatamente para evitar inconsistências
+                console.log('\n🔄 Atualizando package-lock.json (npm install --package-lock-only) ...');
+                execSync('npm install --package-lock-only', { stdio: 'inherit', timeout: 120_000 });
+                console.log('✅ package-lock.json atualizado com sucesso');
+            }
+            catch (err) {
+                console.warn('⚠️ Falha ao atualizar package-lock.json automaticamente:', err?.message || err);
+                console.log('💡 Você pode atualizar manualmente executando: npm install --package-lock-only');
+            }
+        })();
+        break;
+    default:
+        console.log('\n📖 USO DO SMART OVERRIDE:');
+        console.log('═'.repeat(60));
+        console.log('npx autocore-sync check   - Sincroniza dependências scoped (@)');
+        console.log('npx autocore-sync status  - Mostra status das dependências');
+        console.log('npx autocore-sync remove  - Remove overrides locais');
+        console.log('npx autocore-sync sync    - Sincroniza todos os projetos');
+        console.log('═'.repeat(60));
+        console.log('\n💡 COMANDO RECOMENDADO NO package.json:');
+        console.log('');
+        console.log('  "sync": "npx autocore-sync-configs && npx autocore-sync check"');
+        console.log('');
+        console.log('═'.repeat(60));
+        console.log('\n🎯 COMANDOS PARA USUÁRIOS:');
+        console.log('');
+        console.log('📦 Para sincronizar dependências:');
+        console.log('   npm run sync                      - Sincroniza configs e dependências');
+        console.log('   npx autocore-sync check           - Sincroniza dependências scoped (@)');
+        console.log('   npx autocore-sync status          - Mostra dependências atuais');
+        console.log('');
+        console.log('🔧 COMANDOS DE MANUTENÇÃO:');
+        console.log('   npx autocore-sync remove          - Remove overrides locais');
+        console.log('   npm install --force               - Reinstala dependências limpas');
+        console.log('');
+        console.log('═'.repeat(60));
+        console.log('\n🚀 EXEMPLOS DE USO:');
+        console.log('');
+        console.log('# Sincronizar tudo (configurações + dependências):');
+        console.log('npm run sync');
+        console.log('');
+        console.log('# Ver status das dependências:');
+        console.log('npx autocore-sync status');
+        console.log('');
+        console.log('# Voltar para versões do Azure DevOps:');
+        console.log('npx autocore-sync remove');
+        console.log('');
+        console.log('═'.repeat(60));
+}