wegho-agentes 7.0.0 → 7.0.1

package/.agents/utils/report-generator.ts

@@ -1,193 +0,0 @@
-import { execSync } from 'child_process';
-
-/**
- * Report Generator - Gera relatórios executivos de tarefas
- * 
- * Responsabilidades:
- * - Gerar relatório de execução
- * - Documentar arquivos criados/modificados
- * - Listar validações executadas
- * - Fornecer próximos passos
- */
-
-export interface ExecutionReport {
-    task: string;
-    status: 'success' | 'failure';
-    duration: string;
-    filesCreated: string[];
-    filesModified: string[];
-    filesDeleted: string[];
-    validation: {
-        validate: boolean;
-        lint: boolean;
-        build: boolean;
-        test: boolean;
-    };
-    errors: string[];
-    warnings: string[];
-    nextSteps: string[];
-}
-
-export class ReportGenerator {
-    /**
-     * Gera relatório executivo
-     */
-    generateExecutionReport(report: ExecutionReport): string {
-        const statusEmoji = report.status === 'success' ? '✅' : '❌';
-        const statusText = report.status === 'success' ? 'SUCESSO' : 'FALHOU';
-
-        let markdown = `# ${statusEmoji} Execução ${statusText}\n\n`;
-
-        // Resumo
-        markdown += `## 📊 Resumo\n\n`;
-        markdown += `- **Tarefa**: ${report.task}\n`;
-        markdown += `- **Status**: ${statusText}\n`;
-        markdown += `- **Duração**: ${report.duration}\n\n`;
-
-        // Arquivos
-        if (report.filesCreated.length > 0 || report.filesModified.length > 0 || report.filesDeleted.length > 0) {
-            markdown += `## 📁 Arquivos Alterados\n\n`;
-
-            if (report.filesCreated.length > 0) {
-                markdown += `### ✨ Criados (${report.filesCreated.length})\n\n`;
-                report.filesCreated.forEach(f => {
-                    markdown += `- \`${f}\`\n`;
-                });
-                markdown += `\n`;
-            }
-
-            if (report.filesModified.length > 0) {
-                markdown += `### ✏️ Modificados (${report.filesModified.length})\n\n`;
-                report.filesModified.forEach(f => {
-                    markdown += `- \`${f}\`\n`;
-                });
-                markdown += `\n`;
-            }
-
-            if (report.filesDeleted.length > 0) {
-                markdown += `### 🗑️ Deletados (${report.filesDeleted.length})\n\n`;
-                report.filesDeleted.forEach(f => {
-                    markdown += `- \`${f}\`\n`;
-                });
-                markdown += `\n`;
-            }
-        }
-
-        // Validações
-        markdown += `## ✅ Validações\n\n`;
-        markdown += `| Validação | Status |\n`;
-        markdown += `|-----------|--------|\n`;
-        markdown += `| Validate | ${report.validation.validate ? '✅ Passou' : '❌ Falhou'} |\n`;
-        markdown += `| Lint | ${report.validation.lint ? '✅ Passou' : '❌ Falhou'} |\n`;
-        markdown += `| Build | ${report.validation.build ? '✅ Passou' : '❌ Falhou'} |\n`;
-        markdown += `| Tests | ${report.validation.test ? '✅ Passou' : '❌ Falhou'} |\n\n`;
-
-        // Erros
-        if (report.errors.length > 0) {
-            markdown += `## 🚨 Erros\n\n`;
-            report.errors.forEach(err => {
-                markdown += `- ${err}\n`;
-            });
-            markdown += `\n`;
-        }
-
-        // Avisos
-        if (report.warnings.length > 0) {
-            markdown += `## ⚠️ Avisos\n\n`;
-            report.warnings.forEach(warn => {
-                markdown += `- ${warn}\n`;
-            });
-            markdown += `\n`;
-        }
-
-        // Próximos passos
-        if (report.nextSteps.length > 0) {
-            markdown += `## 📚 Próximos Passos\n\n`;
-            report.nextSteps.forEach((step, i) => {
-                markdown += `${i + 1}. ${step}\n`;
-            });
-            markdown += `\n`;
-        }
-
-        // Como testar
-        if (report.status === 'success') {
-            markdown += `## 🧪 Como Testar\n\n`;
-            markdown += `\`\`\`bash\n`;
-            markdown += `npm run dev\n`;
-            markdown += `# Acesse http://localhost:3000\n`;
-            markdown += `\`\`\`\n\n`;
-        }
-
-        markdown += `---\n\n`;
-        markdown += `**Gerado em**: ${new Date().toLocaleString('pt-BR')}\n`;
-
-        return markdown;
-    }
-
-    /**
-     * Salva relatório em arquivo
-     */
-    saveReport(report: ExecutionReport, outputPath: string): void {
-        const markdown = this.generateExecutionReport(report);
-        const fs = require('fs');
-        const path = require('path');
-
-        const dir = path.dirname(outputPath);
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
-        }
-
-        fs.writeFileSync(outputPath, markdown, 'utf-8');
-        console.log(`\n📊 Relatório salvo em: ${outputPath}`);
-    }
-
-    /**
-     * Exibe relatório no console
-     */
-    displayReport(report: ExecutionReport): void {
-        console.log('\n' + '='.repeat(60));
-        console.log(`${report.status === 'success' ? '✅' : '❌'} RELATÓRIO DE EXECUÇÃO`);
-        console.log('='.repeat(60) + '\n');
-
-        console.log(`📋 Tarefa: ${report.task}`);
-        console.log(`⏱️  Duração: ${report.duration}\n`);
-
-        if (report.filesCreated.length > 0) {
-            console.log(`✨ Arquivos criados: ${report.filesCreated.length}`);
-            report.filesCreated.slice(0, 3).forEach(f => console.log(`   - ${f}`));
-            if (report.filesCreated.length > 3) {
-                console.log(`   ... e mais ${report.filesCreated.length - 3}`);
-            }
-            console.log('');
-        }
-
-        if (report.filesModified.length > 0) {
-            console.log(`✏️  Arquivos modificados: ${report.filesModified.length}`);
-            report.filesModified.slice(0, 3).forEach(f => console.log(`   - ${f}`));
-            if (report.filesModified.length > 3) {
-                console.log(`   ... e mais ${report.filesModified.length - 3}`);
-            }
-            console.log('');
-        }
-
-        console.log('✅ Validações:');
-        console.log(`   Validate: ${report.validation.validate ? '✅' : '❌'}`);
-        console.log(`   Lint: ${report.validation.lint ? '✅' : '❌'}`);
-        console.log(`   Build: ${report.validation.build ? '✅' : '❌'}`);
-        console.log(`   Tests: ${report.validation.test ? '✅' : '❌'}\n`);
-
-        if (report.errors.length > 0) {
-            console.log('🚨 Erros:');
-            report.errors.forEach(err => console.log(`   - ${err}`));
-            console.log('');
-        }
-
-        if (report.status === 'success' && report.nextSteps.length > 0) {
-            console.log('📚 Próximos passos:');
-            report.nextSteps.forEach((step, i) => console.log(`   ${i + 1}. ${step}`));
-            console.log('');
-        }
-
-        console.log('='.repeat(60) + '\n');
-    }
-}

package/.agents/utils/retry-utility.ts

@@ -1,140 +0,0 @@
-/**
- * Retry Utility - Implementa retry logic com backoff exponencial
- * 
- * Funcionalidades:
- * - Retry automático em caso de falha
- * - Backoff exponencial (delay aumenta a cada tentativa)
- * - Configurável por tipo de erro
- * - Logging de tentativas
- */
-
-export interface RetryOptions {
-    maxRetries: number;
-    initialDelay: number;
-    maxDelay: number;
-    backoffMultiplier: number;
-    retryableErrors?: string[];
-}
-
-export const DEFAULT_RETRY_OPTIONS: RetryOptions = {
-    maxRetries: 3,
-    initialDelay: 1000,
-    maxDelay: 10000,
-    backoffMultiplier: 2,
-    retryableErrors: ['ETIMEDOUT', 'ECONNRESET', 'ENOTFOUND']
-};
-
-export class RetryUtility {
-    /**
-     * Executa função com retry automático
-     */
-    static async executeWithRetry<T>(
-        fn: () => Promise<T>,
-        options: Partial<RetryOptions> = {},
-        context?: string
-    ): Promise<T> {
-        const opts = { ...DEFAULT_RETRY_OPTIONS, ...options };
-        let lastError: Error;
-
-        for (let attempt = 1; attempt <= opts.maxRetries; attempt++) {
-            try {
-                return await fn();
-            } catch (error: any) {
-                lastError = error;
-
-                // Verificar se erro é retryable
-                if (!this.isRetryableError(error, opts.retryableErrors)) {
-                    throw error;
-                }
-
-                // Última tentativa - não fazer retry
-                if (attempt === opts.maxRetries) {
-                    break;
-                }
-
-                // Calcular delay com backoff exponencial
-                const delay = Math.min(
-                    opts.initialDelay * Math.pow(opts.backoffMultiplier, attempt - 1),
-                    opts.maxDelay
-                );
-
-                console.log(
-                    `⚠️  [Retry] Tentativa ${attempt}/${opts.maxRetries} falhou` +
-                    (context ? ` (${context})` : '') +
-                    `. Retentando em ${delay}ms...`
-                );
-
-                await this.sleep(delay);
-            }
-        }
-
-        throw new Error(
-            `Falha após ${opts.maxRetries} tentativas` +
-            (context ? ` (${context})` : '') +
-            `: ${lastError!.message}`
-        );
-    }
-
-    /**
-     * Verifica se erro é retryable
-     */
-    private static isRetryableError(error: any, retryableErrors?: string[]): boolean {
-        if (!retryableErrors || retryableErrors.length === 0) {
-            return true; // Retry em todos os erros se não especificado
-        }
-
-        const errorCode = error.code || error.name || '';
-        const errorMessage = error.message || '';
-
-        return retryableErrors.some(
-            retryable =>
-                errorCode.includes(retryable) ||
-                errorMessage.includes(retryable)
-        );
-    }
-
-    /**
-     * Sleep helper
-     */
-    private static sleep(ms: number): Promise<void> {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-
-    /**
-     * Executa com timeout
-     */
-    static async executeWithTimeout<T>(
-        fn: () => Promise<T>,
-        timeoutMs: number,
-        context?: string
-    ): Promise<T> {
-        return Promise.race([
-            fn(),
-            new Promise<T>((_, reject) =>
-                setTimeout(
-                    () => reject(new Error(
-                        `Timeout após ${timeoutMs}ms` +
-                        (context ? ` (${context})` : '')
-                    )),
-                    timeoutMs
-                )
-            )
-        ]);
-    }
-
-    /**
-     * Executa com timeout E retry
-     */
-    static async executeWithTimeoutAndRetry<T>(
-        fn: () => Promise<T>,
-        timeoutMs: number,
-        retryOptions: Partial<RetryOptions> = {},
-        context?: string
-    ): Promise<T> {
-        return this.executeWithRetry(
-            () => this.executeWithTimeout(fn, timeoutMs, context),
-            retryOptions,
-            context
-        );
-    }
-}

package/.agents/utils/workflow-validator.ts

@@ -1,158 +0,0 @@
-/**
- * Workflow Validator - Garante que agentes sigam os 6 passos obrigatórios
- * 
- * Passos obrigatórios do AGENT_WORKFLOW.md:
- * 1. Consultar memória para casos similares
- * 2. Obter recomendações de aprendizados
- * 3. Consultar repositórios de referência relevantes
- * 4. Aplicar aprendizados com alta confiança (>0.7)
- * 5. Registrar resultado (sucesso ou falha)
- * 6. Gerar aprendizados baseado em feedback (opcional)
- */
-
-export interface WorkflowStep {
-    name: string;
-    required: boolean;
-    completed: boolean;
-    timestamp?: Date;
-    details?: any;
-}
-
-export interface WorkflowValidationResult {
-    compliant: boolean;
-    missingSteps: string[];
-    warnings: string[];
-    completedSteps: string[];
-    totalRequired: number;
-    totalCompleted: number;
-}
-
-export class WorkflowValidator {
-    /**
-     * Valida se um agente seguiu todos os passos obrigatórios
-     */
-    validateAgentExecution(agentName: string, executionLog: WorkflowStep[]): WorkflowValidationResult {
-        const requiredSteps = executionLog.filter(step => step.required);
-        const completedRequired = requiredSteps.filter(step => step.completed);
-        const missingSteps = requiredSteps
-            .filter(step => !step.completed)
-            .map(step => step.name);
-
-        const warnings: string[] = [];
-        const completedSteps = executionLog
-            .filter(step => step.completed)
-            .map(step => step.name);
-
-        // Verificar se passos foram executados na ordem correta
-        const expectedOrder = [
-            'Consultar Memória',
-            'Obter Recomendações',
-            'Consultar Repositórios',
-            'Aplicar Aprendizados',
-            'Registrar Resultado'
-        ];
-
-        const completedOrder = executionLog
-            .filter(step => step.completed && step.timestamp)
-            .sort((a, b) => a.timestamp!.getTime() - b.timestamp!.getTime())
-            .map(step => step.name);
-
-        // Verificar ordem (warning, não erro)
-        for (let i = 0; i < completedOrder.length - 1; i++) {
-            const currentIndex = expectedOrder.indexOf(completedOrder[i]);
-            const nextIndex = expectedOrder.indexOf(completedOrder[i + 1]);
-
-            if (currentIndex !== -1 && nextIndex !== -1 && currentIndex > nextIndex) {
-                warnings.push(
-                    `Passos executados fora de ordem: "${completedOrder[i]}" antes de "${completedOrder[i + 1]}"`
-                );
-            }
-        }
-
-        // Verificar se passos críticos foram pulados
-        const criticalSteps = ['Consultar Memória', 'Registrar Resultado'];
-        const missingCritical = criticalSteps.filter(
-            step => !completedSteps.includes(step)
-        );
-
-        if (missingCritical.length > 0) {
-            warnings.push(
-                `Passos críticos não executados: ${missingCritical.join(', ')}`
-            );
-        }
-
-        const compliant = missingSteps.length === 0;
-
-        return {
-            compliant,
-            missingSteps,
-            warnings,
-            completedSteps,
-            totalRequired: requiredSteps.length,
-            totalCompleted: completedRequired.length
-        };
-    }
-
-    /**
-     * Gera relatório detalhado de validação
-     */
-    generateValidationReport(agentName: string, validation: WorkflowValidationResult): string {
-        const lines: string[] = [];
-
-        lines.push(`\n━━━ Validação de Workflow: ${agentName} ━━━`);
-        lines.push(`Status: ${validation.compliant ? '✅ COMPLIANT' : '❌ NON-COMPLIANT'}`);
-        lines.push(`Passos Completados: ${validation.totalCompleted}/${validation.totalRequired}`);
-
-        if (validation.completedSteps.length > 0) {
-            lines.push(`\n✅ Passos Executados:`);
-            validation.completedSteps.forEach(step => {
-                lines.push(`   - ${step}`);
-            });
-        }
-
-        if (validation.missingSteps.length > 0) {
-            lines.push(`\n❌ Passos Faltantes:`);
-            validation.missingSteps.forEach(step => {
-                lines.push(`   - ${step}`);
-            });
-        }
-
-        if (validation.warnings.length > 0) {
-            lines.push(`\n⚠️  Avisos:`);
-            validation.warnings.forEach(warning => {
-                lines.push(`   - ${warning}`);
-            });
-        }
-
-        lines.push(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`);
-
-        return lines.join('\n');
-    }
-
-    /**
-     * Valida múltiplos agentes e retorna resumo
-     */
-    validateMultipleAgents(
-        agentExecutions: Array<{ agentName: string; steps: WorkflowStep[] }>
-    ): {
-        allCompliant: boolean;
-        compliantCount: number;
-        nonCompliantCount: number;
-        details: Array<{ agentName: string; validation: WorkflowValidationResult }>;
-    } {
-        const details = agentExecutions.map(({ agentName, steps }) => ({
-            agentName,
-            validation: this.validateAgentExecution(agentName, steps)
-        }));
-
-        const compliantCount = details.filter(d => d.validation.compliant).length;
-        const nonCompliantCount = details.length - compliantCount;
-
-        return {
-            allCompliant: nonCompliantCount === 0,
-            compliantCount,
-            nonCompliantCount,
-            details
-        };
-    }
-}