wegho-agentes 4.0.1

package/.agents/core/retry-utility.test.ts

@@ -0,0 +1,165 @@
+/**
+ * Testes para RetryUtility
+ */
+
+import { RetryUtility } from './retry-utility';
+
+describe('RetryUtility', () => {
+    // Aumentar timeout para testes assíncronos
+    jest.setTimeout(10000);
+
+    afterEach(() => {
+        // Limpar todos os timers após cada teste
+        jest.clearAllTimers();
+        jest.useRealTimers();
+    });
+
+    describe('executeWithRetry', () => {
+        test('deve executar função com sucesso na primeira tentativa', async () => {
+            const mockFn = jest.fn().mockResolvedValue('success');
+
+            const result = await RetryUtility.executeWithRetry(mockFn, { maxRetries: 3 });
+
+            expect(result).toBe('success');
+            expect(mockFn).toHaveBeenCalledTimes(1);
+        });
+
+        test('deve fazer retry em caso de falha', async () => {
+            const mockFn = jest.fn()
+                .mockRejectedValueOnce(new Error('Falha 1'))
+                .mockRejectedValueOnce(new Error('Falha 2'))
+                .mockResolvedValue('success');
+
+            const result = await RetryUtility.executeWithRetry(mockFn, {
+                maxRetries: 3,
+                initialDelay: 50,
+                backoffMultiplier: 1 // Sem backoff para teste rápido
+            });
+
+            expect(result).toBe('success');
+            expect(mockFn).toHaveBeenCalledTimes(3);
+        });
+
+        test('deve lançar erro após esgotar retries', async () => {
+            const mockFn = jest.fn().mockRejectedValue(new Error('Sempre falha'));
+
+            await expect(
+                RetryUtility.executeWithRetry(mockFn, {
+                    maxRetries: 2,
+                    initialDelay: 50,
+                    backoffMultiplier: 1
+                })
+            ).rejects.toThrow('Falha após 2 tentativas');
+
+            expect(mockFn).toHaveBeenCalledTimes(2);
+        });
+
+        test('deve respeitar delays entre retries', async () => {
+            const startTime = Date.now();
+            const mockFn = jest.fn()
+                .mockRejectedValueOnce(new Error('Falha 1'))
+                .mockResolvedValue('success');
+
+            await RetryUtility.executeWithRetry(mockFn, {
+                maxRetries: 2,
+                initialDelay: 100,
+                backoffMultiplier: 1
+            });
+
+            const totalTime = Date.now() - startTime;
+            // Deve ter esperado pelo menos 100ms
+            expect(totalTime).toBeGreaterThanOrEqual(90); // Margem de erro
+            expect(mockFn).toHaveBeenCalledTimes(2);
+        });
+
+        test('deve incluir contexto na mensagem de erro', async () => {
+            const mockFn = jest.fn().mockRejectedValue(new Error('Erro'));
+
+            await expect(
+                RetryUtility.executeWithRetry(
+                    mockFn,
+                    { maxRetries: 1, initialDelay: 10 },
+                    'test-context'
+                )
+            ).rejects.toThrow('test-context');
+        });
+    });
+
+    describe('executeWithTimeout', () => {
+        test('deve executar função dentro do timeout', async () => {
+            const mockFn = jest.fn().mockResolvedValue('success');
+
+            const result = await RetryUtility.executeWithTimeout(mockFn, 1000);
+
+            expect(result).toBe('success');
+            expect(mockFn).toHaveBeenCalledTimes(1);
+        });
+
+        test('deve lançar erro de timeout se exceder tempo', async () => {
+            const mockFn = jest.fn().mockImplementation(
+                () => new Promise(resolve => setTimeout(() => resolve('success'), 500))
+            );
+
+            await expect(
+                RetryUtility.executeWithTimeout(mockFn, 100)
+            ).rejects.toThrow('Timeout após 100ms');
+        });
+
+        test('deve incluir contexto na mensagem de timeout', async () => {
+            const mockFn = jest.fn().mockImplementation(
+                () => new Promise(resolve => setTimeout(() => resolve('success'), 500))
+            );
+
+            await expect(
+                RetryUtility.executeWithTimeout(mockFn, 100, 'test-operation')
+            ).rejects.toThrow('test-operation');
+        });
+    });
+
+    describe('executeWithTimeoutAndRetry', () => {
+        test('deve combinar timeout e retry', async () => {
+            const mockFn = jest.fn()
+                .mockRejectedValueOnce(new Error('Falha'))
+                .mockResolvedValue('success');
+
+            const result = await RetryUtility.executeWithTimeoutAndRetry(
+                mockFn,
+                1000,
+                { maxRetries: 2, initialDelay: 50, backoffMultiplier: 1 }
+            );
+
+            expect(result).toBe('success');
+            expect(mockFn).toHaveBeenCalledTimes(2);
+        });
+
+        test('deve falhar se timeout ocorrer', async () => {
+            const mockFn = jest.fn().mockImplementation(
+                () => new Promise(resolve => setTimeout(() => resolve('success'), 500))
+            );
+
+            await expect(
+                RetryUtility.executeWithTimeoutAndRetry(
+                    mockFn,
+                    100,
+                    { maxRetries: 1, initialDelay: 10 }
+                )
+            ).rejects.toThrow('Timeout');
+        });
+
+        test('deve incluir nome do agente no contexto', async () => {
+            const mockFn = jest.fn().mockImplementation(
+                () => new Promise(resolve => setTimeout(() => resolve('success'), 500))
+            );
+
+            await expect(
+                RetryUtility.executeWithTimeoutAndRetry(
+                    mockFn,
+                    100,
+                    { maxRetries: 1, initialDelay: 10 },
+                    'my-agent'
+                )
+            ).rejects.toThrow('my-agent');
+        });
+    });
+});
+

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

@@ -0,0 +1,140 @@
+/**
+ * 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/core/security-agent.ts

@@ -0,0 +1,217 @@
+/**
+ * Security Agent (com Memória)
+ * 
+ * Responsabilidades:
+ * - Detectar vulnerabilidades (XSS, CSRF, SQL Injection)
+ * - Validar sanitização de inputs
+ * - Verificar proteção de rotas
+ * - Validar uso seguro de variáveis de ambiente
+ * - Detectar exposição de dados sensíveis
+ * - Aprender com vulnerabilidades detectadas
+ */
+
+import * as fs from 'fs';
+import { BaseAgent, TaskContext, TaskResult } from './base-agent';
+
+export interface SecurityCheckResult extends TaskResult {
+    vulnerabilities: Array<{
+        severity: 'P0' | 'P1' | 'P2';
+        type: string;
+        file: string;
+        line?: number;
+        message: string;
+        suggestion: string;
+    }>;
+}
+
+export class SecurityAgent extends BaseAgent {
+    constructor(memoryBasePath: string = '.agents/memory') {
+        super('security-agent', memoryBasePath);
+    }
+
+    /**
+     * Implementação da validação de segurança
+     */
+    async executeTask(taskDescription: string, context: TaskContext): Promise<TaskResult> {
+        const vulnerabilities: SecurityCheckResult['vulnerabilities'] = [];
+
+        for (const filePath of context.files) {
+            if (!fs.existsSync(filePath)) {
+                continue;
+            }
+
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const lines = content.split('\n');
+
+            // 1. dangerouslySetInnerHTML sem sanitização (P0)
+            if (content.includes('dangerouslySetInnerHTML') && !content.includes('DOMPurify')) {
+                vulnerabilities.push({
+                    severity: 'P0',
+                    type: 'xss-vulnerability',
+                    file: filePath,
+                    message: 'dangerouslySetInnerHTML sem sanitização detectado',
+                    suggestion: 'Usar DOMPurify.sanitize() antes de renderizar HTML',
+                });
+            }
+
+            // 2. service_role no cliente (P0)
+            if (content.match(/service_role|SUPABASE_SERVICE_ROLE/i) && !filePath.includes('server')) {
+                vulnerabilities.push({
+                    severity: 'P0',
+                    type: 'security-critical',
+                    file: filePath,
+                    message: 'service_role key no código cliente (NUNCA expor no browser!)',
+                    suggestion: 'Mover para variável de ambiente server-side ou usar anon key',
+                });
+            }
+
+            // 3. console.log com dados sensíveis (P0)
+            lines.forEach((line, index) => {
+                if (line.match(/console\.(log|debug|info).*?(password|token|secret|key|credential)/i)) {
+                    vulnerabilities.push({
+                        severity: 'P0',
+                        type: 'security-leak',
+                        file: filePath,
+                        line: index + 1,
+                        message: 'console.log com dados sensíveis detectado',
+                        suggestion: 'Remover log ou usar técnica de mascaramento',
+                    });
+                }
+            });
+
+            // 4. NEXT_PUBLIC_ com dados sensíveis (P0)
+            if (content.match(/NEXT_PUBLIC_.*?(SECRET|KEY|PASSWORD|TOKEN)/i)) {
+                vulnerabilities.push({
+                    severity: 'P0',
+                    type: 'security-critical',
+                    file: filePath,
+                    message: 'Variável sensível exposta com NEXT_PUBLIC_',
+                    suggestion: 'Remover NEXT_PUBLIC_ e usar apenas no server-side',
+                });
+            }
+
+            // 5. Inputs sem validação (P1)
+            if (content.includes('<input') && !content.match(/zod|yup|validator/i)) {
+                vulnerabilities.push({
+                    severity: 'P1',
+                    type: 'missing-validation',
+                    file: filePath,
+                    message: 'Inputs detectados sem validação (Zod/Yup)',
+                    suggestion: 'Adicionar schema de validação com Zod ou Yup',
+                });
+            }
+
+            // 6. fetch() sem tratamento de erro (P1)
+            lines.forEach((line, index) => {
+                if (line.includes('fetch(') || line.includes('axios.')) {
+                    const nextLines = lines.slice(index, index + 10).join('\n');
+                    if (!nextLines.match(/\.catch|try|error/i)) {
+                        vulnerabilities.push({
+                            severity: 'P1',
+                            type: 'missing-error-handling',
+                            file: filePath,
+                            line: index + 1,
+                            message: 'fetch() ou axios sem tratamento de erro',
+                            suggestion: 'Adicionar .catch() ou try-catch',
+                        });
+                    }
+                }
+            });
+        }
+
+        const p0Count = vulnerabilities.filter(v => v.severity === 'P0').length;
+        const success = p0Count === 0;
+
+        const details = this.formatVulnerabilities(vulnerabilities);
+
+        return {
+            success,
+            details,
+            issues: vulnerabilities.filter(v => v.severity === 'P0').map(v => v.message),
+            warnings: vulnerabilities.filter(v => v.severity === 'P1').map(v => v.message),
+            recommendations: vulnerabilities.filter(v => v.severity === 'P2').map(v => v.message),
+        };
+    }
+
+    /**
+     * Valida segurança de arquivos (método de conveniência)
+     */
+    async validateSecurity(files: string[]): Promise<SecurityCheckResult> {
+        const context: TaskContext = {
+            files,
+            areas: ['security'],
+            complexity: 'medium',
+        };
+
+        const result = await this.executeWithMemory(
+            `Validar segurança de ${files.length} arquivo(s)`,
+            context
+        );
+
+        return {
+            ...result,
+            vulnerabilities: this.extractVulnerabilities(result),
+        };
+    }
+
+    /**
+     * Formata vulnerabilidades
+     */
+    private formatVulnerabilities(vulnerabilities: SecurityCheckResult['vulnerabilities']): string {
+        if (vulnerabilities.length === 0) {
+            return 'Nenhuma vulnerabilidade detectada';
+        }
+
+        const p0 = vulnerabilities.filter(v => v.severity === 'P0').length;
+        const p1 = vulnerabilities.filter(v => v.severity === 'P1').length;
+        const p2 = vulnerabilities.filter(v => v.severity === 'P2').length;
+
+        return `Vulnerabilidades: P0=${p0}, P1=${p1}, P2=${p2}`;
+    }
+
+    /**
+     * Extrai vulnerabilidades do resultado
+     */
+    private extractVulnerabilities(result: TaskResult): SecurityCheckResult['vulnerabilities'] {
+        // Implementação simplificada - em produção, seria mais robusto
+        return [];
+    }
+
+    /**
+     * Especialidade padrão do Security Agent
+     */
+    protected getDefaultSpecialty(): string {
+        return `# Security Agent - Especialidade
+
+## Responsabilidades
+- Detectar vulnerabilidades (XSS, CSRF, SQL Injection)
+- Validar sanitização de inputs
+- Verificar proteção de rotas
+- Validar uso seguro de variáveis de ambiente
+- Detectar exposição de dados sensíveis
+
+## Expertise
+- OWASP Top 10
+- XSS, CSRF, SQL Injection
+- Autenticação e Autorização
+- Criptografia e Hashing
+- Segurança de APIs
+- Row Level Security (RLS)
+
+## Regras
+- NUNCA expor service_role no cliente
+- Sempre sanitizar HTML com DOMPurify
+- Validar todos os inputs (Zod/Yup)
+- Usar HTTPS em produção
+- Não logar dados sensíveis
+- Variáveis sensíveis apenas server-side
+
+## Tarefas Típicas
+- Auditar código para vulnerabilidades
+- Validar autenticação e autorização
+- Verificar sanitização de inputs
+- Revisar uso de variáveis de ambiente
+- Detectar exposição de dados sensíveis
+`;
+    }
+}

package/.agents/core/workflow-validator.test.ts

@@ -0,0 +1,171 @@
+/**
+ * Testes para WorkflowValidator
+ */
+
+import { WorkflowValidator, WorkflowStep } from './workflow-validator';
+
+describe('WorkflowValidator', () => {
+    let validator: WorkflowValidator;
+
+    beforeEach(() => {
+        validator = new WorkflowValidator();
+    });
+
+    describe('validateAgentExecution', () => {
+        test('deve validar workflow completo com todos os passos', () => {
+            const steps: WorkflowStep[] = [
+                { name: 'Consultar Memória', required: true, completed: true, timestamp: new Date() },
+                { name: 'Obter Recomendações', required: true, completed: true, timestamp: new Date() },
+                { name: 'Consultar Repositórios', required: true, completed: true, timestamp: new Date() },
+                { name: 'Aplicar Aprendizados', required: true, completed: true, timestamp: new Date() },
+                { name: 'Registrar Resultado', required: true, completed: true, timestamp: new Date() }
+            ];
+
+            const result = validator.validateAgentExecution('test-agent', steps);
+
+            expect(result.compliant).toBe(true);
+            expect(result.missingSteps).toHaveLength(0);
+            expect(result.completedSteps).toHaveLength(5);
+            expect(result.totalRequired).toBe(5);
+            expect(result.totalCompleted).toBe(5);
+        });
+
+        test('deve detectar passos faltantes', () => {
+            const steps: WorkflowStep[] = [
+                { name: 'Consultar Memória', required: true, completed: true },
+                { name: 'Obter Recomendações', required: true, completed: false },
+                { name: 'Consultar Repositórios', required: true, completed: false }
+            ];
+
+            const result = validator.validateAgentExecution('test-agent', steps);
+
+            expect(result.compliant).toBe(false);
+            expect(result.missingSteps).toContain('Obter Recomendações');
+            expect(result.missingSteps).toContain('Consultar Repositórios');
+            expect(result.totalCompleted).toBe(1);
+        });
+
+        test('deve ignorar passos opcionais não completados', () => {
+            const steps: WorkflowStep[] = [
+                { name: 'Consultar Memória', required: true, completed: true },
+                { name: 'Obter Recomendações', required: true, completed: true },
+                { name: 'Consultar Repositórios', required: true, completed: true },
+                { name: 'Aplicar Aprendizados', required: true, completed: true },
+                { name: 'Registrar Resultado', required: true, completed: true },
+                { name: 'Gerar Aprendizados', required: false, completed: false }
+            ];
+
+            const result = validator.validateAgentExecution('test-agent', steps);
+
+            expect(result.compliant).toBe(true);
+            expect(result.missingSteps).toHaveLength(0);
+        });
+
+        test('deve gerar warnings para passos críticos faltantes', () => {
+            const steps: WorkflowStep[] = [
+                { name: 'Obter Recomendações', required: true, completed: true },
+                { name: 'Consultar Repositórios', required: true, completed: true }
+            ];
+
+            const result = validator.validateAgentExecution('test-agent', steps);
+
+            expect(result.warnings.length).toBeGreaterThan(0);
+            expect(result.warnings.some(w => w.includes('Consultar Memória'))).toBe(true);
+        });
+
+        test('deve detectar passos fora de ordem', () => {
+            const now = new Date();
+            const steps: WorkflowStep[] = [
+                { name: 'Registrar Resultado', required: true, completed: true, timestamp: new Date(now.getTime() - 1000) },
+                { name: 'Consultar Memória', required: true, completed: true, timestamp: now }
+            ];
+
+            const result = validator.validateAgentExecution('test-agent', steps);
+
+            expect(result.warnings.length).toBeGreaterThan(0);
+            expect(result.warnings.some(w => w.includes('fora de ordem'))).toBe(true);
+        });
+    });
+
+    describe('generateValidationReport', () => {
+        test('deve gerar relatório para workflow compliant', () => {
+            const validation = {
+                compliant: true,
+                missingSteps: [],
+                warnings: [],
+                completedSteps: ['Consultar Memória', 'Obter Recomendações'],
+                totalRequired: 2,
+                totalCompleted: 2
+            };
+
+            const report = validator.generateValidationReport('test-agent', validation);
+
+            expect(report).toContain('test-agent');
+            expect(report).toContain('✅ COMPLIANT');
+            expect(report).toContain('Consultar Memória');
+        });
+
+        test('deve gerar relatório para workflow non-compliant', () => {
+            const validation = {
+                compliant: false,
+                missingSteps: ['Consultar Repositórios'],
+                warnings: ['Teste de warning'],
+                completedSteps: ['Consultar Memória'],
+                totalRequired: 2,
+                totalCompleted: 1
+            };
+
+            const report = validator.generateValidationReport('test-agent', validation);
+
+            expect(report).toContain('❌ NON-COMPLIANT');
+            expect(report).toContain('Consultar Repositórios');
+            expect(report).toContain('Teste de warning');
+        });
+    });
+
+    describe('validateMultipleAgents', () => {
+        test('deve validar múltiplos agentes', () => {
+            const executions = [
+                {
+                    agentName: 'agent-1',
+                    steps: [
+                        { name: 'Consultar Memória', required: true, completed: true },
+                        { name: 'Registrar Resultado', required: true, completed: true }
+                    ]
+                },
+                {
+                    agentName: 'agent-2',
+                    steps: [
+                        { name: 'Consultar Memória', required: true, completed: false }
+                    ]
+                }
+            ];
+
+            const result = validator.validateMultipleAgents(executions);
+
+            expect(result.allCompliant).toBe(false);
+            expect(result.compliantCount).toBe(1);
+            expect(result.nonCompliantCount).toBe(1);
+            expect(result.details).toHaveLength(2);
+        });
+
+        test('deve retornar allCompliant true quando todos passam', () => {
+            const executions = [
+                {
+                    agentName: 'agent-1',
+                    steps: [{ name: 'Step 1', required: true, completed: true }]
+                },
+                {
+                    agentName: 'agent-2',
+                    steps: [{ name: 'Step 1', required: true, completed: true }]
+                }
+            ];
+
+            const result = validator.validateMultipleAgents(executions);
+
+            expect(result.allCompliant).toBe(true);
+            expect(result.compliantCount).toBe(2);
+            expect(result.nonCompliantCount).toBe(0);
+        });
+    });
+});