@silasfmartins/testhub 1.0.0

package/dist/scripts/update-all-init-scripts.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { getLatestVersions } from './package-versions.ts';
+/**
+ * Script para atualizar todas as versões nos arquivos init
+ */
+async function updateAllInitScripts() {
+    console.log('🔄 Atualizando versões em todos os scripts init...');
+    const versions = await getLatestVersions();
+    console.log('📦 Versões atuais:');
+    console.log('Dependencies:', versions.dependencies);
+    console.log('DevDependencies:', versions.devDependencies);
+    const initFiles = [
+        'init-api.ts',
+        'init-frontend.ts',
+        'init-mobile.ts',
+        'init-ssh.ts',
+        'init-banco.ts',
+        'init-scenarios.ts',
+    ];
+    const scriptsDir = path.join(process.cwd(), 'scripts');
+    for (const file of initFiles) {
+        const filePath = path.join(scriptsDir, file);
+        if (fs.existsSync(filePath)) {
+            console.log(`✏️ Verificando ${file}...`);
+            const content = fs.readFileSync(filePath, 'utf8');
+            // Verificar se já usa o novo sistema
+            if (content.includes('getLatestVersions') &&
+                content.includes('generatePackageJson')) {
+                console.log(`   ✅ ${file} já está atualizado`);
+            }
+            else {
+                console.log(`   📝 ${file} precisa ser atualizado manualmente`);
+            }
+        }
+        else {
+            console.log(`   ⚠️ ${file} não encontrado`);
+        }
+    }
+    console.log('');
+    console.log('💡 Para completar a atualização dos outros init scripts:');
+    console.log('   1. Use o padrão do init-api.ts como base');
+    console.log('   2. Substitua package.json hardcoded pelo generatePackageJson()');
+    console.log('   3. Substitua tsconfig.json por generateTsConfigForProject()');
+    console.log('   4. Adicione setupUltracite() ao final de cada script');
+    console.log('   5. Ajuste o projectType para cada init (api, frontend, mobile, etc.)');
+    console.log('');
+    console.log('✅ Verificação concluída!');
+}
+updateAllInitScripts().catch(console.error);

package/dist/scripts/update-biome-schema.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env tsx
+/**
+ * Script para atualizar o $schema do biome.json baseado na versão do @biomejs/biome
+ * Mantém sincronizado o schema com a versão instalada do pacote
+ *
+ * @example
+ * ```bash
+ * # Execução manual
+ * npx tsx scripts/update-biome-schema.ts
+ *
+ * # Na pipeline Azure DevOps
+ * npm run update:biome-schema
+ * ```
+ */
+export {};

package/dist/scripts/update-biome-schema.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env tsx
+/**
+ * Script para atualizar o $schema do biome.json baseado na versão do @biomejs/biome
+ * Mantém sincronizado o schema com a versão instalada do pacote
+ *
+ * @example
+ * ```bash
+ * # Execução manual
+ * npx tsx scripts/update-biome-schema.ts
+ *
+ * # Na pipeline Azure DevOps
+ * npm run update:biome-schema
+ * ```
+ */
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+const BIOME_PACKAGE_NAME = '@biomejs/biome';
+const BIOME_SCHEMA_BASE_URL = 'https://biomejs.dev/schemas';
+// Regex patterns no escopo superior para performance
+const VERSION_PREFIX_REGEX = /^[\^~]/;
+const SCHEMA_URL_REGEX = /"https:\/\/biomejs\.dev\/schemas\/([^/]+)\/schema\.json"/;
+const SCHEMA_REPLACE_REGEX = /"https:\/\/biomejs\.dev\/schemas\/[^/]+\/schema\.json"/;
+/**
+ * Extrai a versão limpa do @biomejs/biome do package.json
+ */
+function getBiomeVersion() {
+    const packageJsonPath = join(process.cwd(), 'package.json');
+    if (!existsSync(packageJsonPath)) {
+        console.error('❌ package.json não encontrado');
+        return null;
+    }
+    try {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+        const biomeVersion = packageJson.devDependencies?.[BIOME_PACKAGE_NAME] ||
+            packageJson.dependencies?.[BIOME_PACKAGE_NAME];
+        if (!biomeVersion) {
+            console.log(`⚠️  ${BIOME_PACKAGE_NAME} não encontrado no package.json`);
+            return null;
+        }
+        // Remover ^ ou ~ da versão
+        const cleanVersion = biomeVersion.replace(VERSION_PREFIX_REGEX, '');
+        return cleanVersion;
+    }
+    catch (error) {
+        console.error('❌ Erro ao ler package.json:', error.message);
+        return null;
+    }
+}
+/**
+ * Extrai a versão atual do schema do biome.json
+ */
+function getCurrentSchemaVersion(content) {
+    const match = content.match(SCHEMA_URL_REGEX);
+    return match ? match[1] : null;
+}
+/**
+ * Atualiza o $schema no conteúdo do biome.json
+ */
+function updateSchemaInContent(content, newVersion) {
+    const newSchema = `${BIOME_SCHEMA_BASE_URL}/${newVersion}/schema.json`;
+    return content.replace(SCHEMA_REPLACE_REGEX, `"${newSchema}"`);
+}
+/**
+ * Função principal
+ */
+function main() {
+    console.log('🔧 Atualizando schema do biome.json...');
+    console.log('');
+    const biomeJsoncPath = join(process.cwd(), 'biome.json');
+    // Verificar se biome.json existe
+    if (!existsSync(biomeJsoncPath)) {
+        console.log('⚠️  biome.json não encontrado - pulando atualização');
+        process.exit(0);
+    }
+    // Obter versão do @biomejs/biome
+    console.log('📦 Lendo package.json...');
+    const biomeVersion = getBiomeVersion();
+    if (!biomeVersion) {
+        process.exit(0);
+    }
+    console.log(`🔍 Versão do ${BIOME_PACKAGE_NAME} detectada: ${biomeVersion}`);
+    console.log('');
+    // Ler biome.json
+    console.log('📄 Lendo biome.json...');
+    let biomeContent;
+    try {
+        biomeContent = readFileSync(biomeJsoncPath, 'utf8');
+    }
+    catch (error) {
+        console.error('❌ Erro ao ler biome.json:', error.message);
+        process.exit(1);
+    }
+    // Extrair versão atual do schema
+    const currentSchemaVersion = getCurrentSchemaVersion(biomeContent);
+    if (!currentSchemaVersion) {
+        console.log('⚠️  Schema não encontrado no biome.json');
+        process.exit(0);
+    }
+    console.log(`📌 Versão atual do schema: ${currentSchemaVersion}`);
+    console.log('');
+    // Verificar se precisa atualizar
+    if (currentSchemaVersion === biomeVersion) {
+        console.log('✅ Schema já está sincronizado com a versão do pacote!');
+        console.log(`   Versão: ${biomeVersion}`);
+        process.exit(0);
+    }
+    // Atualizar o schema
+    console.log('🔄 Atualizando schema...');
+    const updatedContent = updateSchemaInContent(biomeContent, biomeVersion);
+    // Salvar arquivo atualizado
+    try {
+        writeFileSync(biomeJsoncPath, updatedContent, 'utf8');
+        console.log('✅ biome.json atualizado com sucesso!');
+        console.log(`   ${currentSchemaVersion} → ${biomeVersion}`);
+        console.log('');
+        console.log(`   $schema: ${BIOME_SCHEMA_BASE_URL}/${biomeVersion}/schema.json`);
+    }
+    catch (error) {
+        console.error('❌ Erro ao salvar biome.json:', error.message);
+        process.exit(1);
+    }
+}
+// Executar
+main();

package/dist/src/AutoCoreFacade.d.ts

@@ -0,0 +1,145 @@
+/**
+ * @fileoverview Facade do AutoCore para compatibilidade com arquitetura DDD
+ * @module AutoCore/Facade
+ */
+import type { BrowserContext, Page } from '@playwright/test';
+import type { IMobileDriver } from './infrastructure/adapters/AppiumAdapter.js';
+import type { IDatabaseClient } from './infrastructure/adapters/OracleAdapter.js';
+import type { IWebDriver } from './infrastructure/adapters/PlaywrightAdapter.js';
+import type { ISSHClient } from './infrastructure/adapters/SSHAdapter.js';
+import type { DIContainer } from './infrastructure/DependencyContainer.js';
+import './playwright/registerRecoveryWrappers.js';
+/**
+ * Configuração para inicialização do AutoCore
+ */
+export type AutoCoreConfig = {
+    playwright?: {
+        page: Page;
+        context?: BrowserContext;
+    };
+    appium?: {
+        driver: unknown;
+        deviceConfig?: MobileDeviceConfig;
+    };
+    ssh?: {
+        host: string;
+        port: number;
+        username: string;
+        password?: string;
+        privateKey?: string;
+        passphrase?: string;
+    };
+    database?: {
+        host: string;
+        port: number;
+        database: string;
+        username: string;
+        password: string;
+        connectionTimeout?: number;
+        queryTimeout?: number;
+    };
+    container?: DIContainer;
+};
+/**
+ * Configuração de dispositivo móvel
+ */
+export type MobileDeviceConfig = {
+    platformName: string;
+    deviceName: string;
+    app?: string;
+    appPackage?: string;
+    appActivity?: string;
+    bundleId?: string;
+    udid?: string;
+    platformVersion?: string;
+};
+/**
+ * Contexto de execução do AutoCore
+ * Fornece acesso aos serviços configurados
+ */
+export declare class AutoCoreContext {
+    readonly container: DIContainer;
+    constructor(container: DIContainer);
+    /**
+     * Obtém driver web (Playwright)
+     */
+    getWebDriver(): Promise<IWebDriver>;
+    /**
+     * Obtém driver móvel (Appium)
+     */
+    getMobileDriver(): Promise<IMobileDriver>;
+    /**
+     * Obtém cliente SSH
+     */
+    getSSHClient(): Promise<ISSHClient>;
+    /**
+     * Obtém cliente de banco de dados
+     */
+    getDatabaseClient(): Promise<IDatabaseClient>;
+    /**
+     * Acesso direto ao container para casos avançados
+     */
+    getContainer(): DIContainer;
+    /**
+     * Limpa recursos e conexões
+     */
+    dispose(): Promise<void>;
+}
+/**
+ * Facade principal do AutoCore
+ * Simplifica a inicialização e uso da arquitetura DDD
+ */
+export declare class AutoCore {
+    /**
+     * Inicializa o AutoCore com a configuração especificada
+     */
+    static initialize(config: AutoCoreConfig): Promise<AutoCoreContext>;
+    /**
+     * Cria contexto apenas para APIs (mais leve)
+     */
+    static forAPI(): Promise<AutoCoreContext>;
+    /**
+     * Cria contexto para Web com Playwright
+     */
+    static forWeb(page: Page, context?: BrowserContext): Promise<AutoCoreContext>;
+    /**
+     * Cria contexto para Mobile com Appium
+     */
+    static forMobile(driver: unknown, deviceConfig?: MobileDeviceConfig): Promise<AutoCoreContext>;
+    /**
+     * Cria contexto híbrido Web + Mobile
+     */
+    static forHybrid(page: Page, driver: unknown, options?: {
+        webContext?: BrowserContext;
+        deviceConfig?: MobileDeviceConfig;
+    }): Promise<AutoCoreContext>;
+    /**
+     * 🔧 RETROCOMPATIBILIDADE: Permite usar Actions atuais com DI opcional
+     * Não quebra código existente, apenas adiciona DI se disponível
+     */
+    static enableDDDMode(enable?: boolean): void;
+}
+/**
+ * 🔄 MIGRAÇÃO GRADUAL: Permite transição suave para DDD
+ *
+ * FASE 1: Usar Actions atuais (sem mudanças)
+ * ```typescript
+ * import { ApiActions } from '@silasfmartins/testhub'
+ * await ApiActions.post(request, 'desc')
+ * ```
+ *
+ * FASE 2: Adicionar DDD gradualmente
+ * ```typescript
+ * import { AutoCore, ApiActions } from '@silasfmartins/testhub'
+ * AutoCore.enableDDDMode(true) // Opcional
+ * await ApiActions.post(request, 'desc') // Continua igual
+ * ```
+ *
+ * FASE 3: Usar DDD completo (quando pronto)
+ * ```typescript
+ * import { AutoCore } from '@silasfmartins/testhub'
+ * const context = await AutoCore.forWeb(page)
+ * const webDriver = await context.getWebDriver()
+ * await webDriver.click('button')
+ * ```
+ */

package/dist/src/AutoCoreFacade.js

@@ -0,0 +1,217 @@
+/**
+ * @fileoverview Facade do AutoCore para compatibilidade com arquitetura DDD
+ * @module AutoCore/Facade
+ */
+import { AutoDocs } from './hubdocs/HubDocs.js';
+import { defaultContainer } from './infrastructure/DependencyContainer.js';
+import { CoverageManager } from './testContext/CoverageManager.js';
+import { TerminalLogCapture } from './utils/TerminalLogCapture.js';
+import { Logger } from './utils/Logger.js';
+// Registrar wrappers de recovery globalmente para WebActions
+import './playwright/registerRecoveryWrappers.js';
+/**
+ * Contexto de execução do AutoCore
+ * Fornece acesso aos serviços configurados
+ */
+export class AutoCoreContext {
+    container;
+    constructor(container) {
+        this.container = container;
+    }
+    /**
+     * Obtém driver web (Playwright)
+     */
+    async getWebDriver() {
+        return await this.container.resolve('webDriver');
+    }
+    /**
+     * Obtém driver móvel (Appium)
+     */
+    async getMobileDriver() {
+        return await this.container.resolve('mobileDriver');
+    }
+    /**
+     * Obtém cliente SSH
+     */
+    async getSSHClient() {
+        return await this.container.resolve('sshClient');
+    }
+    /**
+     * Obtém cliente de banco de dados
+     */
+    async getDatabaseClient() {
+        return await this.container.resolve('databaseClient');
+    }
+    /**
+     * Acesso direto ao container para casos avançados
+     */
+    getContainer() {
+        return this.container;
+    }
+    /**
+     * Limpa recursos e conexões
+     */
+    async dispose() {
+        try {
+            // 📚 NOVO: Gerar documentação automática ao finalizar
+            await AutoDocs.generateDocs();
+        }
+        catch (error) {
+            Logger.warning(` ⚠️ AutoDocs: Erro ao gerar documentação final: ${error}`);
+        }
+        // Tentar fechar conexões SSH
+        try {
+            if (this.container.hasService('sshClient')) {
+                const sshClient = await this.container.resolve('sshClient');
+                await sshClient.disconnect();
+            }
+        }
+        catch {
+            // Ignorar erros de limpeza
+        }
+        // Tentar fechar conexões de banco
+        try {
+            if (this.container.hasService('databaseClient')) {
+                const dbClient = await this.container.resolve('databaseClient');
+                await dbClient.disconnect();
+            }
+        }
+        catch {
+            // Ignorar erros de limpeza
+        }
+        // Tentar fechar drivers móveis
+        try {
+            if (this.container.hasService('mobileDriver')) {
+                const mobileDriver = await this.container.resolve('mobileDriver');
+                await mobileDriver.quit();
+            }
+        }
+        catch {
+            // Ignorar erros de limpeza
+        }
+        // Tentar fechar drivers web
+        try {
+            if (this.container.hasService('webDriver')) {
+                const webDriver = await this.container.resolve('webDriver');
+                await webDriver.close();
+            }
+        }
+        catch {
+            // Ignorar erros de limpeza
+        }
+        // Limpar instâncias do container
+        this.container.clearInstances();
+    }
+}
+/**
+ * Facade principal do AutoCore
+ * Simplifica a inicialização e uso da arquitetura DDD
+ */
+export class AutoCore {
+    /**
+     * Inicializa o AutoCore com a configuração especificada
+     */
+    static async initialize(config) {
+        // ✅ CRÍTICO: Iniciar captura de logs no Worker para garantir que StatementTracker tenha acesso
+        TerminalLogCapture.start();
+        globalThis.TerminalLogCapture = TerminalLogCapture;
+        const container = config.container || defaultContainer.createScope();
+        // 📚 NOVO: Inicializar sistema de documentação automática
+        try {
+            AutoDocs.initialize({
+                outputDir: './docs/generated',
+            });
+        }
+        catch (error) {
+            Logger.warning(` ⚠️ AutoDocs: Erro ao inicializar documentação automática: ${error}`);
+        }
+        // 📊 NOVO: Inicializar sistema de cobertura
+        try {
+            await CoverageManager.autoInitialize();
+        }
+        catch (error) {
+            Logger.warning(`⚠️ Coverage: Erro ao inicializar sistema de cobertura: ${error}`);
+        }
+        return new AutoCoreContext(container);
+    }
+    /**
+     * Cria contexto apenas para APIs (mais leve)
+     */
+    static async forAPI() {
+        return await AutoCore.initialize({});
+    }
+    /**
+     * Cria contexto para Web com Playwright
+     */
+    static async forWeb(page, context) {
+        return await AutoCore.initialize({
+            playwright: { page, context },
+        });
+    }
+    /**
+     * Cria contexto para Mobile com Appium
+     */
+    static async forMobile(driver, deviceConfig) {
+        return await AutoCore.initialize({
+            appium: { driver, deviceConfig },
+        });
+    }
+    /**
+     * Cria contexto híbrido Web + Mobile
+     */
+    static async forHybrid(page, driver, options) {
+        return await AutoCore.initialize({
+            playwright: {
+                page,
+                context: options?.webContext,
+            },
+            appium: {
+                driver,
+                deviceConfig: options?.deviceConfig,
+            },
+        });
+    }
+    /**
+     * 🔧 RETROCOMPATIBILIDADE: Permite usar Actions atuais com DI opcional
+     * Não quebra código existente, apenas adiciona DI se disponível
+     */
+    static enableDDDMode(enable = true) {
+        if (enable) {
+            // Registra Actions no container global para DI opcional
+            try {
+                // Actions continuam funcionando independente de DI
+                // DI é apenas uma camada adicional opcional
+                if (defaultContainer) {
+                    // Container está disponível
+                }
+            }
+            catch {
+                // Se falhar, Actions funcionam normalmente sem DI
+            }
+        }
+    }
+}
+/**
+ * 🔄 MIGRAÇÃO GRADUAL: Permite transição suave para DDD
+ *
+ * FASE 1: Usar Actions atuais (sem mudanças)
+ * ```typescript
+ * import { ApiActions } from '@silasfmartins/testhub'
+ * await ApiActions.post(request, 'desc')
+ * ```
+ *
+ * FASE 2: Adicionar DDD gradualmente
+ * ```typescript
+ * import { AutoCore, ApiActions } from '@silasfmartins/testhub'
+ * AutoCore.enableDDDMode(true) // Opcional
+ * await ApiActions.post(request, 'desc') // Continua igual
+ * ```
+ *
+ * FASE 3: Usar DDD completo (quando pronto)
+ * ```typescript
+ * import { AutoCore } from '@silasfmartins/testhub'
+ * const context = await AutoCore.forWeb(page)
+ * const webDriver = await context.getWebDriver()
+ * await webDriver.click('button')
+ * ```
+ */