@silasfmartins/testhub 1.0.0

package/dist/scripts/sync-configs.d.ts

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+/**
+ * 🔄 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.
+ */
+/**
+ * 🔍 Detecta o tipo de projeto baseado no package.json
+ */
+declare function detectProjectType(): 'api' | 'frontend' | 'mobile' | 'ssh' | 'banco' | 'scenarios' | 'unknown';
+/**
+ * 💾 Atualiza biome.json no projeto consumidor
+ */
+declare function syncBiomeConfig(): boolean;
+/**
+ * 💾 Atualiza tsconfig.json no projeto consumidor
+ */
+declare function syncTsConfig(): boolean;
+/**
+ * 🔄 Sincroniza todas as configurações
+ */
+declare function syncAllConfigs(): Promise<void>;
+export { syncAllConfigs, syncBiomeConfig, syncTsConfig, detectProjectType };

package/dist/scripts/sync-configs.js

@@ -0,0 +1,248 @@
+#!/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) {
+    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() {
+    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() {
+    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() {
+    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() {
+    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() {
+    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/dist/scripts/test-biome-parse.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env tsx
+/**
+ * Script de teste para validar o parse do biome.json
+ */
+export {};

package/dist/scripts/test-biome-parse.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env tsx
+/**
+ * Script de teste para validar o parse do biome.json
+ */
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+// Constantes para códigos ASCII de caracteres de controle
+const ASCII_NULL = 0;
+const ASCII_BACKSPACE = 8;
+const ASCII_VERTICAL_TAB = 11;
+const ASCII_FORM_FEED = 12;
+const ASCII_SHIFT_OUT = 14;
+const ASCII_UNIT_SEPARATOR = 31;
+// Regex para remover caracteres de controle
+const CONTROL_CHARS_REGEX = new RegExp(`[${String.fromCharCode(ASCII_NULL)}-${String.fromCharCode(ASCII_BACKSPACE)}${String.fromCharCode(ASCII_VERTICAL_TAB)}${String.fromCharCode(ASCII_FORM_FEED)}${String.fromCharCode(ASCII_SHIFT_OUT)}-${String.fromCharCode(ASCII_UNIT_SEPARATOR)}]`, 'g');
+function parseJsonc(content) {
+    console.log('📋 Iniciando parse JSONC...');
+    console.log(`   Tamanho original: ${content.length} caracteres`);
+    // 1. Remover comentários de bloco /* */
+    let cleaned = content.replace(/\/\*[\s\S]*?\*\//g, '');
+    console.log(`   Após remover /* */: ${cleaned.length} caracteres`);
+    // 2. Remover comentários de linha // (estratégia: processar linha por linha)
+    const lines = cleaned.split('\n');
+    const processedLines = lines.map((line) => {
+        // Se a linha tem aspas, verificar se // está dentro de string
+        if (line.includes('"')) {
+            // Encontrar posição de //
+            const commentPos = line.indexOf('//');
+            if (commentPos === -1)
+                return line; // Sem comentário
+            // Verificar se // está dentro de string (contar aspas antes)
+            const beforeComment = line.substring(0, commentPos);
+            const quoteCount = (beforeComment.match(/"/g) || []).length;
+            // Se número ímpar de aspas, // está dentro de string
+            if (quoteCount % 2 === 1) {
+                return line; // Manter linha inteira
+            }
+            // // está fora de string, remover comentário
+            return line.substring(0, commentPos);
+        }
+        // Linha sem aspas, pode remover // normalmente
+        const commentPos = line.indexOf('//');
+        return commentPos === -1 ? line : line.substring(0, commentPos);
+    });
+    cleaned = processedLines.join('\n');
+    console.log(`   Após remover //: ${cleaned.length} caracteres`);
+    // 3. Normalizar quebras de linha
+    cleaned = cleaned.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    console.log(`   Após normalizar line endings: ${cleaned.length} caracteres`);
+    // 4. Remover caracteres de controle inválidos
+    const beforeControl = cleaned.length;
+    cleaned = cleaned.replace(CONTROL_CHARS_REGEX, '');
+    const removedControl = beforeControl - cleaned.length;
+    if (removedControl > 0) {
+        console.log(`   Removidos ${removedControl} caracteres de controle`);
+    }
+    // 5. Remover trailing commas
+    cleaned = cleaned.replace(/,(\s*[}\]])/g, '$1');
+    console.log(`   Após remover trailing commas: ${cleaned.length} caracteres`);
+    // 6. Trim e fazer parse
+    const trimmed = cleaned.trim();
+    console.log(`   Após trim: ${trimmed.length} caracteres`);
+    console.log('');
+    console.log('📄 JSON limpo:');
+    console.log(trimmed);
+    console.log('');
+    return JSON.parse(trimmed);
+}
+// Testar
+try {
+    const biomeJsoncPath = join(process.cwd(), 'biome.json');
+    console.log(`🔍 Lendo: ${biomeJsoncPath}`);
+    console.log('');
+    const content = readFileSync(biomeJsoncPath, 'utf-8');
+    const config = parseJsonc(content);
+    console.log('✅ Parse bem-sucedido!');
+    console.log('');
+    console.log('📦 Configuração carregada:');
+    console.log(JSON.stringify(config, null, 2));
+}
+catch (error) {
+    console.error('❌ Erro:', error);
+    process.exit(1);
+}

package/dist/scripts/ultracite-setup.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Configuração automatizada do Ultracite com GitHub Copilot
+ */
+export declare function setupUltracite(projectRoot: string): Promise<void>;

package/dist/scripts/ultracite-setup.js

@@ -0,0 +1,310 @@
+// @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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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');
+}

package/dist/scripts/update-all-init-scripts.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};