@silasfmartins/testhub 1.0.0

package/scripts/sync-configs.ts

@@ -0,0 +1,302 @@
+#!/usr/bin/env node
+// @ts-nocheck
+/**
+ * 🔄 Sync Configs Script
+ * @description Sincroniza biome.json e tsconfig.json do AutoCore para o projeto consumidor
+ * @author TestHUB Team
+ * @version 1.0.0
+ *
+ * Este script atualiza automaticamente os arquivos de configuração do projeto
+ * baseados nas configurações mais recentes do AutoCore.
+ */
+
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+// ✅ ESM Compatibility
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+/**
+ * ✅ Parse JSONC (suporta comentários, trailing commas e caracteres de controle)
+ */
+function parseJsonc(content: string): any {
+  try {
+    // 1. Remover comentários de bloco /* */
+    let cleaned = content.replace(/\/\*[\s\S]*?\*\//g, '')
+
+    // 2. Remover comentários de linha // respeitando strings
+    const lines = cleaned.split('\n')
+    const processedLines = lines.map((line) => {
+      if (!line.includes('//')) {
+        return line
+      }
+
+      const commentPos = line.indexOf('//')
+      if (commentPos === -1) {
+        return line
+      }
+
+      const beforeComment = line.substring(0, commentPos)
+      const quoteCount = (beforeComment.match(/"/g) || []).length
+
+      // Se estamos dentro de uma string, manter linha inteira
+      if (quoteCount % 2 === 1) {
+        return line
+      }
+
+      return beforeComment
+    })
+
+    cleaned = processedLines.join('\n')
+
+    // 3. Normalizar quebras de linha
+    cleaned = cleaned.replace(/\r\n/g, '\n').replace(/\r/g, '\n')
+
+    // 4. Remover caracteres de controle inválidos
+    cleaned = cleaned.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F]/g, '')
+
+    // 5. Remover trailing commas
+    cleaned = cleaned.replace(/,(\s*[}\]])/g, '$1')
+
+    return JSON.parse(cleaned.trim())
+  } catch (error) {
+    console.warn('⚠️ Erro ao fazer parse JSONC:', error)
+    throw error
+  }
+}
+
+/**
+ * 🔍 Detecta o tipo de projeto baseado no package.json
+ */
+function detectProjectType():
+  | 'api'
+  | 'frontend'
+  | 'mobile'
+  | 'ssh'
+  | 'banco'
+  | 'scenarios'
+  | 'unknown' {
+  try {
+    const packageJsonPath = path.join(process.cwd(), 'package.json')
+    if (!fs.existsSync(packageJsonPath)) {
+      return 'unknown'
+    }
+
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'))
+    const projectName = packageJson.name || ''
+
+    if (projectName.includes('scenarios') || projectName.includes('cenarios')) {
+      return 'scenarios'
+    }
+    if (projectName.includes('api')) {
+      return 'api'
+    }
+    if (projectName.includes('mobile')) {
+      return 'mobile'
+    }
+    if (projectName.includes('ssh')) {
+      return 'ssh'
+    }
+    if (projectName.includes('banco') || projectName.includes('db')) {
+      return 'banco'
+    }
+    if (projectName.includes('frontend') || projectName.includes('web')) {
+      return 'frontend'
+    }
+
+    return 'unknown'
+  } catch (error) {
+    console.warn('⚠️ Erro ao detectar tipo de projeto:', error)
+    return 'unknown'
+  }
+}
+
+/**
+ * 📋 Lê o biome.json do AutoCore
+ */
+function getAutocoreBiomeConfig(): any {
+  try {
+    // Caminhos a serem tentados (em ordem de prioridade)
+    // __dirname quando compilado via bin: node_modules/@silasfmartins/testhub/dist/scripts
+    // __dirname quando executado via tsx: node_modules/@silasfmartins/testhub/scripts
+    const autoCorePaths = [
+      // 1. Instalado via npm/pnpm - caminho absoluto (MAIS CONFIÁVEL)
+      path.join(
+        process.cwd(),
+        'node_modules',
+        '@rbqa',
+        'autocore',
+        'biome.json',
+      ),
+      // 2. Quando executado do dist/scripts (via bin)
+      path.resolve(__dirname, '..', '..', 'biome.json'),
+      // 3. Quando executado do scripts/ (via tsx)
+      path.resolve(__dirname, '..', 'biome.json'),
+      // 4. Fallback - subindo mais níveis
+      path.resolve(__dirname, '..', '..', '..', 'biome.json'),
+      // 5. Desenvolvimento local (projeto autocore)
+      path.resolve(process.cwd(), 'biome.json'),
+    ]
+
+    for (const biomePath of autoCorePaths) {
+      if (fs.existsSync(biomePath)) {
+        const biomeContent = fs.readFileSync(biomePath, 'utf8')
+        console.log(`✅ biome.json carregado de: ${biomePath}`)
+        return JSON.parse(biomeContent)
+      }
+    }
+
+    console.warn('⚠️ biome.json do AutoCore não encontrado')
+    console.warn('   Caminhos verificados:')
+    for (const p of autoCorePaths) {
+      console.warn(`   - ${p}`)
+    }
+    return null
+  } catch (error) {
+    console.error('❌ Erro ao ler biome.json:', error)
+    return null
+  }
+}
+
+/**
+ * 📋 Lê o tsconfig.json do AutoCore
+ */
+function getAutocoreTsConfig(): any {
+  try {
+    // Caminhos a serem tentados (em ordem de prioridade)
+    // __dirname quando compilado via bin: node_modules/@silasfmartins/testhub/dist/scripts
+    // __dirname quando executado via tsx: node_modules/@silasfmartins/testhub/scripts
+    const autoCorePaths = [
+      // 1. Instalado via npm/pnpm - caminho absoluto (MAIS CONFIÁVEL)
+      path.join(
+        process.cwd(),
+        'node_modules',
+        '@rbqa',
+        'autocore',
+        'tsconfig.json',
+      ),
+      // 2. Quando executado do dist/scripts (via bin)
+      path.resolve(__dirname, '..', '..', 'tsconfig.json'),
+      // 3. Quando executado do scripts/ (via tsx)
+      path.resolve(__dirname, '..', 'tsconfig.json'),
+      // 4. Fallback - subindo mais níveis
+      path.resolve(__dirname, '..', '..', '..', 'tsconfig.json'),
+      // 5. Desenvolvimento local (projeto autocore)
+      path.resolve(process.cwd(), 'tsconfig.json'),
+    ]
+
+    for (const tsconfigPath of autoCorePaths) {
+      if (fs.existsSync(tsconfigPath)) {
+        const tsconfigContent = fs.readFileSync(tsconfigPath, 'utf8')
+        console.log(`✅ tsconfig.json carregado de: ${tsconfigPath}`)
+        return parseJsonc(tsconfigContent)
+      }
+    }
+
+    console.warn('⚠️ tsconfig.json do AutoCore não encontrado')
+    console.warn('   Caminhos verificados:')
+    for (const p of autoCorePaths) {
+      console.warn(`   - ${p}`)
+    }
+    return null
+  } catch (error) {
+    console.error('❌ Erro ao ler tsconfig.json:', error)
+    return null
+  }
+}
+
+/**
+ * 💾 Atualiza biome.json no projeto consumidor
+ */
+function syncBiomeConfig(): boolean {
+  try {
+    const biomeConfig = getAutocoreBiomeConfig()
+    if (!biomeConfig) {
+      return false
+    }
+
+    const targetPath = path.join(process.cwd(), 'biome.json')
+    fs.writeFileSync(targetPath, JSON.stringify(biomeConfig, null, 2), 'utf8')
+    console.log('✅ biome.json atualizado com sucesso!')
+    return true
+  } catch (error) {
+    console.error('❌ Erro ao atualizar biome.json:', error)
+    return false
+  }
+}
+
+/**
+ * 💾 Atualiza tsconfig.json no projeto consumidor
+ */
+function syncTsConfig(): boolean {
+  try {
+    const tsconfigConfig = getAutocoreTsConfig()
+    if (!tsconfigConfig) {
+      return false
+    }
+
+    const targetPath = path.join(process.cwd(), 'tsconfig.json')
+    fs.writeFileSync(
+      targetPath,
+      JSON.stringify(tsconfigConfig, null, 2),
+      'utf8',
+    )
+    console.log('✅ tsconfig.json atualizado com sucesso!')
+    return true
+  } catch (error) {
+    console.error('❌ Erro ao atualizar tsconfig.json:', error)
+    return false
+  }
+}
+
+/**
+ * 🔄 Sincroniza todas as configurações
+ */
+async function syncAllConfigs() {
+  console.log('\n🔄 Sincronizando configurações do AutoCore...\n')
+
+  const projectType = detectProjectType()
+  console.log(`📦 Tipo de projeto detectado: ${projectType}\n`)
+
+  let biomeSuccess = false
+  let tsconfigSuccess = false
+
+  // Sincronizar biome.json
+  console.log('📋 Sincronizando biome.json...')
+  biomeSuccess = syncBiomeConfig()
+
+  // Sincronizar tsconfig.json
+  console.log('\n📋 Sincronizando tsconfig.json...')
+  tsconfigSuccess = syncTsConfig()
+
+  console.log('\n' + '='.repeat(60))
+  console.log('📊 RESUMO DA SINCRONIZAÇÃO:')
+  console.log('='.repeat(60))
+  console.log(`   ${biomeSuccess ? '✅' : '❌'} biome.json`)
+  console.log(`   ${tsconfigSuccess ? '✅' : '❌'} tsconfig.json`)
+  console.log('='.repeat(60))
+
+  if (biomeSuccess && tsconfigSuccess) {
+    console.log('\n✨ Todas as configurações foram sincronizadas com sucesso!')
+  } else {
+    console.log('\n⚠️ Algumas configurações não puderam ser sincronizadas.')
+    console.log('   Verifique se o @silasfmartins/testhub está instalado corretamente.')
+  }
+}
+
+// 🚀 Executar sincronização se for chamado diretamente
+const isMainModule =
+  process.argv[1]?.endsWith('sync-configs.ts') ||
+  process.argv[1]?.endsWith('sync-configs.js')
+
+if (isMainModule) {
+  syncAllConfigs().catch((error) => {
+    console.error('❌ Erro fatal na sincronização:', error)
+    process.exit(1)
+  })
+}
+
+// Exportar funções para uso em outros scripts
+export { syncAllConfigs, syncBiomeConfig, syncTsConfig, detectProjectType }

package/scripts/ultracite-setup.ts

@@ -0,0 +1,370 @@
+// @ts-nocheck
+import fs from 'node:fs'
+import { execSync } from 'child_process'
+import path from 'path'
+
+/**
+ * Configuração automatizada do Ultracite com GitHub Copilot
+ */
+export async function setupUltracite(projectRoot: string): Promise<void> {
+  console.log('🤖 Configurando Ultracite com GitHub Copilot...')
+
+  try {
+    // Verificar se o Ultracite foi instalado
+    const packageJsonPath = path.join(projectRoot, 'package.json')
+    if (!fs.existsSync(packageJsonPath)) {
+      throw new Error('package.json não encontrado')
+    }
+
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'))
+
+    if (!packageJson.devDependencies?.ultracite) {
+      console.log(
+        '⚠️ Ultracite não encontrado nas dependências, pulando configuração',
+      )
+      return
+    }
+
+    console.log(
+      '🔧 Configurando Ultracite automaticamente com GitHub Copilot...',
+    )
+
+    // ✅ PRIMEIRO: Criar configuração VS Code com GitHub Copilot
+    await createVSCodeConfig(projectRoot)
+
+    // ✅ SEGUNDO: Executar ultracite init com parâmetros específicos
+    await runUltraciteInit(projectRoot)
+
+    console.log('✅ Ultracite configurado com sucesso')
+    console.log('🎯 GitHub Copilot habilitado para desenvolvimento')
+    console.log('💡 Para configuração avançada, execute: npx ultracite init')
+  } catch (error) {
+    console.warn(`⚠️ Erro na configuração do Ultracite: ${error}`)
+    console.log(
+      '💡 Você pode configurar manualmente executando: npx ultracite init',
+    )
+
+    // ✅ FALLBACK: Aplicar configuração básica do GitHub Copilot mesmo se o Ultracite falhar
+    try {
+      await createGitHubCopilotVSCodeConfig(projectRoot)
+      console.log('✅ Configuração básica do GitHub Copilot aplicada')
+    } catch (fallbackError) {
+      console.warn(
+        '⚠️ Não foi possível configurar GitHub Copilot automaticamente',
+      )
+    }
+  }
+}
+
+/**
+ * Executar ultracite init de forma automatizada com GitHub Copilot
+ */
+async function runUltraciteInit(projectRoot: string): Promise<void> {
+  try {
+    console.log('🔄 Executando ultracite init com GitHub Copilot...')
+
+    // ✅ NOVO: Criar arquivo de configuração com GitHub Copilot
+    const ultraciteConfig = {
+      editor: 'vscode',
+      frameworks: ['playwright'],
+      tools: [],
+      additionalOptions: [],
+    }
+
+    // ✅ NOVO: Tentar executar com parâmetros específicos para GitHub Copilot
+    try {
+      const initCommand = [
+        'npx ultracite init',
+        '--yes',
+        '--editor=vscode',
+        '--editor-rules=github-copilot',
+        '--frameworks=playwright',
+      ].join(' ')
+
+      console.log(`🎯 Executando: ${initCommand}`)
+
+      execSync(initCommand, {
+        cwd: projectRoot,
+        stdio: 'pipe',
+        timeout: 45_000, // Aumentar timeout para 45s
+        encoding: 'utf8',
+      })
+
+      console.log('✅ Ultracite configurado com GitHub Copilot')
+    } catch (execError) {
+      console.log(
+        'ℹ️ Comando automático falhou, tentando configuração interativa simulada...',
+      )
+
+      // ✅ FALLBACK: Tentar configuração manual programática
+      await setupUltraciteManually(projectRoot)
+    }
+  } catch (error) {
+    console.log(
+      'ℹ️ Aplicando configuração manual do Ultracite com GitHub Copilot',
+    )
+    await setupUltraciteManually(projectRoot)
+  }
+}
+
+/**
+ * ✅ NOVO: Setup manual do Ultracite com GitHub Copilot
+ */
+async function setupUltraciteManually(projectRoot: string): Promise<void> {
+  try {
+    // ✅ Criar configurações específicas do GitHub Copilot para VS Code
+    await createGitHubCopilotVSCodeConfig(projectRoot)
+
+    console.log(
+      '✅ Configuração manual do Ultracite aplicada com GitHub Copilot',
+    )
+  } catch (error) {
+    console.warn(`⚠️ Erro na configuração manual: ${error}`)
+  }
+}
+
+/**
+ * ✅ ATUALIZADO: Criar configurações específicas do GitHub Copilot para VS Code (SEM ESLint)
+ */
+async function createGitHubCopilotVSCodeConfig(
+  projectRoot: string,
+): Promise<void> {
+  const vscodeDir = path.join(projectRoot, '.vscode')
+
+  if (!fs.existsSync(vscodeDir)) {
+    fs.mkdirSync(vscodeDir, { recursive: true })
+  }
+
+  // ✅ Configurações específicas do GitHub Copilot + Pretty TypeScript Errors
+  const copilotSettings = {
+    // Configurações do GitHub Copilot
+    'github.copilot.enable': {
+      '*': true,
+      plaintext: true,
+      markdown: true,
+      typescript: true,
+      javascript: true,
+    },
+    'github.copilot.inlineSuggest.enable': true,
+    'github.copilot.chat.enabled': true,
+
+    // Configurações para melhor integração com Playwright
+    'github.copilot.autocomplete.enable': true,
+    'github.copilot.suggest.showDiffs': true,
+
+    // ✅ Pretty TypeScript Errors
+    'typescript.preferences.includePackageJsonAutoImports': 'auto',
+    'typescript.suggest.autoImports': true,
+    'typescript.updateImportsOnFileMove.enabled': 'always',
+    'typescript.preferences.importModuleSpecifier': 'relative',
+
+    // Configurações específicas para testes
+    'files.associations': {
+      '*.spec.ts': 'typescript',
+      '*.test.ts': 'typescript',
+      '*.page.ts': 'typescript',
+    },
+
+    // ✅ Configurações de formatação (sem ESLint)
+    'editor.formatOnSave': true,
+    'editor.codeActionsOnSave': {
+      'source.organizeImports': true,
+    },
+    'editor.defaultFormatter': 'biomejs.biome',
+    '[typescript]': {
+      'editor.defaultFormatter': 'biomejs.biome',
+    },
+    '[javascript]': {
+      'editor.defaultFormatter': 'biomejs.biome',
+    },
+
+    // Snippets e IntelliSense aprimorados
+    'typescript.suggest.completeFunctionCalls': true,
+    'typescript.suggest.includeCompletionsForImportStatements': true,
+    'typescript.inlayHints.enumMemberValues.enabled': true,
+    'typescript.inlayHints.functionLikeReturnTypes.enabled': true,
+    'typescript.inlayHints.parameterNames.enabled': 'all',
+    'typescript.inlayHints.parameterTypes.enabled': true,
+    'typescript.inlayHints.propertyDeclarationTypes.enabled': true,
+    'typescript.inlayHints.variableTypes.enabled': true,
+  }
+
+  const settingsPath = path.join(vscodeDir, 'settings.json')
+
+  // Mesclar com configurações existentes
+  let existingSettings = {}
+  if (fs.existsSync(settingsPath)) {
+    try {
+      const existingContent = fs.readFileSync(settingsPath, 'utf8')
+      existingSettings = JSON.parse(existingContent)
+    } catch (error) {
+      console.warn('⚠️ Erro ao ler settings.json existente')
+    }
+  }
+
+  const mergedSettings = { ...existingSettings, ...copilotSettings }
+  fs.writeFileSync(settingsPath, JSON.stringify(mergedSettings, null, 2))
+
+  // ✅ ATUALIZADO: Extensões recomendadas (SEM ESLint)
+  const extensions = {
+    recommendations: [
+      'github.copilot', // ✅ GitHub Copilot principal
+      'github.copilot-chat', // ✅ GitHub Copilot Chat
+      'ms-playwright.playwright', // Playwright
+      'biomejs.biome', // Biome (formatação/linting)
+      'yoavbls.pretty-ts-errors', // ✅ Pretty TypeScript Errors
+      'ms-vscode.vscode-typescript-next', // TypeScript
+      'bradlc.vscode-tailwindcss', // Tailwind (se usar)
+      'ms-vscode.vscode-json', // JSON
+      'esbenp.prettier-vscode', // Prettier (backup do Biome)
+      'gruntfuggly.todo-tree', // TODO Tree (útil para desenvolvimento)
+      'streetsidesoftware.code-spell-checker', // Spell Checker
+    ],
+  }
+
+  const extensionsPath = path.join(vscodeDir, 'extensions.json')
+
+  // Mesclar extensões sem duplicatas
+  let existingExtensions = { recommendations: [] }
+  if (fs.existsSync(extensionsPath)) {
+    try {
+      const existingContent = fs.readFileSync(extensionsPath, 'utf8')
+      existingExtensions = JSON.parse(existingContent)
+    } catch (error) {
+      console.warn('⚠️ Erro ao ler extensions.json existente')
+    }
+  }
+
+  const allRecommendations = [
+    ...new Set([
+      ...(existingExtensions.recommendations || []),
+      ...extensions.recommendations,
+    ]),
+  ]
+
+  const mergedExtensions = {
+    ...existingExtensions,
+    recommendations: allRecommendations,
+  }
+
+  fs.writeFileSync(extensionsPath, JSON.stringify(mergedExtensions, null, 2))
+
+  console.log(
+    '✅ Configuração GitHub Copilot + Pretty TypeScript Errors aplicada ao VS Code',
+  )
+}
+
+/**
+ * Criar configuração do VS Code para desenvolvimento
+ */
+async function createVSCodeConfig(projectRoot: string): Promise<void> {
+  const vscodeDir = path.join(projectRoot, '.vscode')
+
+  // Criar diretório .vscode se não existir
+  if (!fs.existsSync(vscodeDir)) {
+    fs.mkdirSync(vscodeDir, { recursive: true })
+  }
+
+  // Configuração básica do VS Code para TypeScript/Playwright (SEM ESLint)
+  const vscodeSettings = {
+    'typescript.preferences.includePackageJsonAutoImports': 'auto',
+    'typescript.suggest.autoImports': true,
+    'typescript.preferences.importModuleSpecifier': 'relative',
+    'editor.codeActionsOnSave': {
+      'source.fixAll': 'explicit',
+      'source.organizeImports': 'explicit',
+    },
+    'editor.formatOnSave': true,
+    'editor.defaultFormatter': 'biomejs.biome',
+    'files.associations': {
+      '*.spec.ts': 'typescript',
+      '*.test.ts': 'typescript',
+    },
+    'search.exclude': {
+      '**/node_modules': true,
+      '**/dist': true,
+      '**/.git': true,
+      '**/test-results': true,
+      '**/playwright-report': true,
+    },
+    'files.exclude': {
+      '**/node_modules': true,
+      '**/dist': true,
+      '**/.git': true,
+    },
+    'typescript.preferences.quoteStyle': 'single',
+    'javascript.preferences.quoteStyle': 'single',
+  }
+
+  const settingsPath = path.join(vscodeDir, 'settings.json')
+
+  // Mesclar com configurações existentes se houver
+  let existingSettings = {}
+  if (fs.existsSync(settingsPath)) {
+    try {
+      const existingContent = fs.readFileSync(settingsPath, 'utf8')
+      existingSettings = JSON.parse(existingContent)
+    } catch (error) {
+      console.warn('⚠️ Erro ao ler settings.json existente, criando novo')
+    }
+  }
+
+  const mergedSettings = { ...existingSettings, ...vscodeSettings }
+  fs.writeFileSync(settingsPath, JSON.stringify(mergedSettings, null, 2))
+
+  // Extensões recomendadas (SEM ESLint)
+  const extensions = {
+    recommendations: ['ms-playwright.playwright', 'biomejs.biome'],
+  }
+
+  const extensionsPath = path.join(vscodeDir, 'extensions.json')
+
+  // Mesclar extensões se já existirem
+  let existingExtensions = { recommendations: [] }
+  if (fs.existsSync(extensionsPath)) {
+    try {
+      const existingContent = fs.readFileSync(extensionsPath, 'utf8')
+      existingExtensions = JSON.parse(existingContent)
+    } catch (error) {
+      console.warn('⚠️ Erro ao ler extensions.json existente, criando novo')
+    }
+  }
+
+  // Combinar recomendações sem duplicatas
+  const allRecommendations = [
+    ...new Set([
+      ...(existingExtensions.recommendations || []),
+      ...extensions.recommendations,
+    ]),
+  ]
+
+  const mergedExtensions = {
+    ...existingExtensions,
+    recommendations: allRecommendations,
+  }
+
+  fs.writeFileSync(extensionsPath, JSON.stringify(mergedExtensions, null, 2))
+
+  // Criar launch.json para debug
+  const launchConfig = {
+    version: '0.2.0',
+    configurations: [
+      {
+        name: 'Debug Playwright Tests',
+        type: 'node',
+        request: 'launch',
+        program: '${workspaceFolder}/node_modules/@playwright/test/cli.js',
+        args: ['test', '--debug'],
+        console: 'integratedTerminal',
+        internalConsoleOptions: 'neverOpen',
+      },
+    ],
+  }
+
+  const launchPath = path.join(vscodeDir, 'launch.json')
+  if (!fs.existsSync(launchPath)) {
+    fs.writeFileSync(launchPath, JSON.stringify(launchConfig, null, 2))
+  }
+
+  console.log('✅ Configuração VS Code criada/atualizada')
+}