@silasfmartins/testhub 1.0.0

package/scripts/smart-override.ts

@@ -0,0 +1,1675 @@
+#!/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: string): boolean {
+  return name.startsWith('@') && name.includes('/')
+}
+
+interface LocalPackage {
+  name: string
+  version: string
+  path: string
+  lastBuild: number
+  buildDuration?: number
+  buildDetails?: {
+    compiledFiles?: number
+    buildSize?: string
+    nodeVersion?: string
+    timestamp?: string
+  }
+}
+
+interface WatchedProject {
+  name: string
+  path: string
+  lastChecked: number
+  dependencies: { [pkg: string]: string }
+}
+
+interface BuildMetrics {
+  startTime: number
+  endTime?: number
+  duration?: number
+  compiledFiles: number
+  buildSize: string
+  success: boolean
+  errors: string[]
+  warnings: string[]
+}
+
+class SmartOverride {
+  private buildMetrics: BuildMetrics = {
+    startTime: Date.now(),
+    compiledFiles: 0,
+    buildSize: '0 KB',
+    success: false,
+    errors: [],
+    warnings: [],
+  }
+
+  private getLocalRegistry(): Record<string, LocalPackage> {
+    try {
+      if (fs.existsSync(LOCAL_REGISTRY)) {
+        return JSON.parse(fs.readFileSync(LOCAL_REGISTRY, 'utf8'))
+      }
+    } catch {}
+    return {}
+  }
+
+  private saveLocalRegistry(registry: Record<string, LocalPackage>): void {
+    fs.writeFileSync(LOCAL_REGISTRY, JSON.stringify(registry, null, 2))
+  }
+
+  private getWatchRegistry(): Record<string, WatchedProject> {
+    try {
+      if (fs.existsSync(WATCH_REGISTRY)) {
+        return JSON.parse(fs.readFileSync(WATCH_REGISTRY, 'utf8'))
+      }
+    } catch {}
+    return {}
+  }
+
+  private saveWatchRegistry(registry: Record<string, WatchedProject>): void {
+    fs.writeFileSync(WATCH_REGISTRY, JSON.stringify(registry, null, 2))
+  }
+
+  /**
+   * Calcula o tamanho de um diretório recursivamente
+   */
+  private calculateDirectorySize(dirPath: string): number {
+    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
+   */
+  private formatSize(bytes: number): string {
+    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
+   */
+  private countCompiledFiles(distPath: string): number {
+    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
+   */
+  private formatDuration(ms: number): string {
+    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
+   */
+  private showBuildStartBanner(packageName: string, version: string): void {
+    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
+   */
+  private showBuildSummary(packageName: string, version: string): void {
+    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(): void {
+    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
+   */
+  private registerAsWatchableProject(packageName: string): void {
+    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
+          },
+          {} as { [pkg: string]: string },
+        ),
+    }
+
+    this.saveWatchRegistry(watchRegistry)
+  }
+
+  /**
+   * Notifica e atualiza automaticamente projetos que dependem do pacote atual
+   */
+  private notifyDependentProjects(packageName: string): void {
+    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
+   */
+  private applyOverrideToProject(
+    watchedProject: WatchedProject,
+    packageName: string,
+    localPkg: LocalPackage,
+  ): boolean {
+    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(): void {
+    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: string | null = 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)
+   */
+  private checkIfExistsInAzure(packageName: string): boolean {
+    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
+   */
+  private getLatestAzureVersion(packageName: string): string | null {
+    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
+   */
+  private installFromAzure(packageName: string, version?: string): boolean {
+    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
+      }
+    }
+  }
+
+  private compareVersions(v1: string, v2: string): number {
+    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
+  }
+
+  private applyOverride(packageName: string, localPkg: LocalPackage): boolean {
+    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
+    }
+  }
+
+  private copyFiles(source: string, destination: string): void {
+    // 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(): void {
+    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: string[] = []
+
+    // 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(): void {
+    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
+   */
+  private updateLocalRegistry(): void {
+    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(): void {
+    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: string | null = 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))
+}