wegho-agentes 4.0.1

package/.agents/core/architecture-agent.ts

@@ -0,0 +1,237 @@
+/**
+ * Architecture Agent (com Memória)
+ * 
+ * Responsabilidades:
+ * - Validar estrutura de arquivos
+ * - Garantir limite de 500 linhas por arquivo
+ * - Detectar duplicação de código
+ * - Validar separação de camadas
+ * - Aprender padrões arquiteturais que funcionam
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { BaseAgent, TaskContext, TaskResult } from './base-agent';
+import { validateFileLines } from '../config';
+
+export interface ArchitectureCheckResult extends TaskResult {
+    violations: Array<{
+        type: string;
+        file: string;
+        severity: 'error' | 'warning';
+        message: string;
+        suggestion: string;
+    }>;
+}
+
+export class ArchitectureAgent extends BaseAgent {
+    constructor(memoryBasePath: string = '.agents/memory') {
+        super('architecture-agent', memoryBasePath);
+    }
+
+    /**
+     * Implementação da validação arquitetural
+     */
+    async executeTask(taskDescription: string, context: TaskContext): Promise<TaskResult> {
+        const violations: ArchitectureCheckResult['violations'] = [];
+
+        for (const filePath of context.files) {
+            if (!fs.existsSync(filePath)) {
+                continue;
+            }
+
+            // 1. Verificar limite de 500 linhas
+            const lineCheck = validateFileLines(filePath, 500);
+            if (!lineCheck.valid) {
+                violations.push({
+                    type: 'file-too-long',
+                    file: filePath,
+                    severity: 'error',
+                    message: `Arquivo tem ${lineCheck.lineCount} linhas (limite: 500)`,
+                    suggestion: 'Refatorar: extrair funções, componentes ou classes para arquivos separados'
+                });
+            }
+
+            const content = fs.readFileSync(filePath, 'utf-8');
+
+            // 2. Detectar duplicação de código
+            const duplicates = this.detectCodeDuplication(content);
+            if (duplicates.length > 0) {
+                violations.push({
+                    type: 'code-duplication',
+                    file: filePath,
+                    severity: 'warning',
+                    message: `${duplicates.length} bloco(s) de código duplicado detectado(s)`,
+                    suggestion: 'Extrair código duplicado para funções/componentes reutilizáveis'
+                });
+            }
+
+            // 3. Validar separação de camadas
+            const layerViolations = this.validateLayerSeparation(filePath, content);
+            violations.push(...layerViolations);
+
+            // 4. Verificar nomenclatura
+            const namingIssues = this.validateNaming(filePath);
+            violations.push(...namingIssues);
+        }
+
+        const errors = violations.filter(v => v.severity === 'error');
+        const success = errors.length === 0;
+
+        const details = this.formatViolations(violations);
+
+        return {
+            success,
+            details,
+            issues: errors.map(v => v.message),
+            warnings: violations.filter(v => v.severity === 'warning').map(v => v.message),
+        };
+    }
+
+    /**
+     * Detecta duplicação de código
+     */
+    private detectCodeDuplication(content: string): string[] {
+        const duplicates: string[] = [];
+        const lines = content.split('\n');
+        const blockSize = 5; // Mínimo de 5 linhas para considerar duplicação
+
+        // Algoritmo simplificado - em produção usaria algo como jscpd
+        const blocks = new Map<string, number>();
+
+        for (let i = 0; i <= lines.length - blockSize; i++) {
+            const block = lines.slice(i, i + blockSize).join('\n').trim();
+            if (block.length > 50) { // Ignorar blocos muito pequenos
+                const count = blocks.get(block) || 0;
+                blocks.set(block, count + 1);
+            }
+        }
+
+        blocks.forEach((count, block) => {
+            if (count > 1) {
+                duplicates.push(block.substring(0, 100) + '...');
+            }
+        });
+
+        return duplicates;
+    }
+
+    /**
+     * Valida separação de camadas
+     */
+    private validateLayerSeparation(filePath: string, content: string): ArchitectureCheckResult['violations'] {
+        const violations: ArchitectureCheckResult['violations'] = [];
+
+        // Componentes não devem ter lógica de API direta
+        if (filePath.includes('components/') && !filePath.includes('pages/')) {
+            if (content.match(/fetch\(|axios\.|supabase\./)) {
+                violations.push({
+                    type: 'layer-violation',
+                    file: filePath,
+                    severity: 'warning',
+                    message: 'Componente com chamada de API direta',
+                    suggestion: 'Extrair lógica de API para hook customizado ou service'
+                });
+            }
+        }
+
+        // Utils não devem importar componentes
+        if (filePath.includes('utils/') || filePath.includes('lib/')) {
+            if (content.match(/import.*from.*components/)) {
+                violations.push({
+                    type: 'layer-violation',
+                    file: filePath,
+                    severity: 'error',
+                    message: 'Arquivo de utilidade importando componente',
+                    suggestion: 'Utils devem ser independentes de componentes UI'
+                });
+            }
+        }
+
+        return violations;
+    }
+
+    /**
+     * Valida nomenclatura de arquivos
+     */
+    private validateNaming(filePath: string): ArchitectureCheckResult['violations'] {
+        const violations: ArchitectureCheckResult['violations'] = [];
+        const fileName = path.basename(filePath);
+
+        // Componentes React devem usar PascalCase
+        if (filePath.includes('components/') && fileName.match(/^[a-z]/)) {
+            violations.push({
+                type: 'naming-convention',
+                file: filePath,
+                severity: 'warning',
+                message: 'Componente deve usar PascalCase',
+                suggestion: `Renomear para ${fileName.charAt(0).toUpperCase() + fileName.slice(1)}`
+            });
+        }
+
+        // Hooks devem começar com 'use'
+        if (filePath.includes('hooks/') && !fileName.startsWith('use')) {
+            violations.push({
+                type: 'naming-convention',
+                file: filePath,
+                severity: 'warning',
+                message: 'Hook customizado deve começar com "use"',
+                suggestion: `Renomear para use${fileName.charAt(0).toUpperCase() + fileName.slice(1)}`
+            });
+        }
+
+        return violations;
+    }
+
+    /**
+     * Formata violações
+     */
+    private formatViolations(violations: ArchitectureCheckResult['violations']): string {
+        if (violations.length === 0) {
+            return 'Arquitetura validada com sucesso';
+        }
+
+        const errors = violations.filter(v => v.severity === 'error').length;
+        const warnings = violations.filter(v => v.severity === 'warning').length;
+
+        return `Violações: ${errors} erro(s), ${warnings} aviso(s)`;
+    }
+
+    /**
+     * Especialidade padrão do Architecture Agent
+     */
+    protected getDefaultSpecialty(): string {
+        return `# Architecture Agent - Especialidade
+
+## Responsabilidades
+- Validar estrutura de arquivos
+- Garantir limite de 500 linhas por arquivo
+- Detectar duplicação de código
+- Validar separação de camadas (MVC, Clean Architecture)
+- Verificar nomenclatura consistente
+
+## Expertise
+- Design Patterns (Factory, Strategy, Observer, etc.)
+- SOLID Principles
+- Clean Architecture
+- Microservices Architecture
+- Modularização e Componentização
+- DRY (Don't Repeat Yourself)
+
+## Regras
+- Máximo 500 linhas por arquivo
+- Sem duplicação de código (DRY)
+- Separação clara de responsabilidades
+- Nomenclatura consistente (PascalCase para componentes, camelCase para funções)
+- Componentes UI não devem ter lógica de API
+- Utils devem ser independentes de UI
+
+## Tarefas Típicas
+- Validar estrutura de novos componentes
+- Detectar código duplicado
+- Sugerir refatorações
+- Validar separação de camadas
+- Revisar nomenclatura de arquivos
+`;
+    }
+}

package/.agents/core/base-agent.ts

@@ -0,0 +1,311 @@
+/**
+ * Base Agent - Classe base para todos os agentes
+ * 
+ * Responsabilidades:
+ * - Fornecer interface comum para todos os agentes
+ * - Integrar sistema de memória
+ * - Gerenciar consulta e registro de resultados
+ * - Implementar aprendizado contínuo
+ */
+
+import { MemorySystem, MemoryEntry } from './memory-system';
+import { WorkflowStep } from './workflow-validator';
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface TaskContext {
+    files: string[];
+    areas: string[];
+    complexity: 'low' | 'medium' | 'high';
+}
+
+export interface TaskResult {
+    success: boolean;
+    details: string;
+    issues?: string[];
+    warnings?: string[];
+    recommendations?: string[];
+}
+
+export interface UserFeedback {
+    satisfied: boolean;
+    likes: string[];
+    dislikes: string[];
+    suggestions: string[];
+}
+
+/**
+ * Classe base abstrata para agentes
+ */
+export abstract class BaseAgent {
+    protected agentName: string;
+    protected memory: MemorySystem;
+    protected specialtyPath: string;
+    protected workflowSteps: WorkflowStep[] = [];
+    protected referenceReposPath: string;
+
+    constructor(agentName: string, memoryBasePath: string = '.agents/memory') {
+        this.agentName = agentName;
+        this.memory = new MemorySystem(memoryBasePath);
+        this.specialtyPath = path.join(memoryBasePath, agentName, 'specialty.md');
+        this.referenceReposPath = path.join(memoryBasePath, 'reference-repositories.json');
+        this.ensureSpecialtyFile();
+        this.initializeWorkflowSteps();
+    }
+
+    /**
+     * Método abstrato: cada agente implementa sua lógica
+     */
+    abstract executeTask(taskDescription: string, context: TaskContext): Promise<TaskResult>;
+
+    /**
+     * Executa tarefa consultando memória
+     */
+    async executeWithMemory(taskDescription: string, context: TaskContext): Promise<TaskResult> {
+        console.log(`\n${'='.repeat(60)}`);
+        console.log(`🤖 AGENTE ATIVO: ${this.agentName.toUpperCase()}`);
+        console.log(`${'='.repeat(60)}`);
+        console.log(`📋 Tarefa: ${taskDescription}`);
+        console.log(`⏰ Início: ${new Date().toLocaleTimeString('pt-BR')}\n`);
+
+        // PASSO 1: Consultar casos similares
+        this.markStepCompleted('Consultar Memória', { count: 0 });
+        const similarCases = this.memory.getSimilarCases(this.agentName, taskDescription, 5);
+
+        if (similarCases.length > 0) {
+            console.log(`💭 [${this.agentName}] Encontrei ${similarCases.length} caso(s) similar(es):`);
+            similarCases.forEach((case_, index) => {
+                const emoji = case_.result === 'success' ? '✅' : '❌';
+                console.log(`  ${index + 1}. ${emoji} ${case_.taskDescription}`);
+                if (case_.userFeedback) {
+                    console.log(`     Feedback: ${case_.userFeedback.satisfied ? '👍' : '👎'}`);
+                }
+            });
+            this.updateStepDetails('Consultar Memória', { count: similarCases.length });
+        }
+
+        // PASSO 2: Obter recomendações baseadas em aprendizados
+        this.markStepCompleted('Obter Recomendações', { count: 0 });
+        const recommendations = this.memory.getRecommendations(this.agentName, taskDescription);
+
+        if (recommendations.length > 0) {
+            console.log(`\n💡 [${this.agentName}] Recomendações baseadas em aprendizados:`);
+            recommendations.forEach((rec, index) => {
+                console.log(`  ${index + 1}. ${rec}`);
+            });
+            this.updateStepDetails('Obter Recomendações', { count: recommendations.length });
+        }
+
+        // PASSO 3: Consultar repositórios de referência
+        this.markStepCompleted('Consultar Repositórios');
+        await this.consultReferenceRepositories();
+
+        // PASSO 4: Aplicar aprendizados com alta confiança
+        this.markStepCompleted('Aplicar Aprendizados');
+        this.applyHighConfidenceLearnings(recommendations);
+
+        // Executar tarefa
+        console.log(`\n⚙️  [${this.agentName}] Executando tarefa...\n`);
+        const result = await this.executeTask(taskDescription, context);
+
+        // PASSO 5: Registrar resultado
+        this.markStepCompleted('Registrar Resultado');
+        await this.recordOutcome(taskDescription, context, result);
+
+        const status = result.success ? '✅ SUCESSO' : '❌ FALHA';
+        console.log(`\n${status} [${this.agentName}] Tarefa concluída`);
+        console.log(`⏰ Término: ${new Date().toLocaleTimeString('pt-BR')}`);
+        console.log(`${'='.repeat(60)}\n`);
+
+        return result;
+    }
+
+    /**
+     * Registra resultado na memória
+     */
+    async recordOutcome(
+        taskDescription: string,
+        context: TaskContext,
+        result: TaskResult,
+        userFeedback?: UserFeedback
+    ): Promise<void> {
+        if (result.success) {
+            this.memory.recordSuccess(
+                this.agentName,
+                taskDescription,
+                context,
+                result.details,
+                userFeedback
+            );
+        } else {
+            this.memory.recordFailure(
+                this.agentName,
+                taskDescription,
+                context,
+                result.details,
+                userFeedback
+            );
+        }
+    }
+
+    /**
+     * Adiciona aprendizado baseado em feedback
+     */
+    async learn(
+        pattern: string,
+        description: string,
+        recommendation: string,
+        exampleIds: string[] = []
+    ): Promise<void> {
+        this.memory.addLearning(
+            this.agentName,
+            pattern,
+            description,
+            recommendation,
+            exampleIds
+        );
+    }
+
+    /**
+     * Obtém estatísticas do agente
+     */
+    getStats() {
+        return this.memory.getStats(this.agentName);
+    }
+
+    /**
+     * Lê arquivo de especialidade
+     */
+    getSpecialty(): string {
+        if (fs.existsSync(this.specialtyPath)) {
+            return fs.readFileSync(this.specialtyPath, 'utf-8');
+        }
+        return 'Especialidade não definida';
+    }
+
+    /**
+     * Garante que arquivo de especialidade existe
+     */
+    private ensureSpecialtyFile(): void {
+        const agentDir = path.dirname(this.specialtyPath);
+
+        if (!fs.existsSync(agentDir)) {
+            fs.mkdirSync(agentDir, { recursive: true });
+        }
+
+        if (!fs.existsSync(this.specialtyPath)) {
+            const defaultSpecialty = this.getDefaultSpecialty();
+            fs.writeFileSync(this.specialtyPath, defaultSpecialty, 'utf-8');
+        }
+    }
+
+    /**
+     * Retorna especialidade padrão (pode ser sobrescrito)
+     */
+    protected getDefaultSpecialty(): string {
+        return `# ${this.agentName} - Especialidade
+
+## Responsabilidades
+- Definir responsabilidades específicas
+
+## Expertise
+- Definir áreas de expertise
+
+## Regras
+- Definir regras específicas
+
+## Tarefas Típicas
+- Listar tarefas típicas
+`;
+    }
+
+    /**
+     * Inicializa os passos do workflow
+     */
+    private initializeWorkflowSteps(): void {
+        this.workflowSteps = [
+            { name: 'Consultar Memória', required: true, completed: false },
+            { name: 'Obter Recomendações', required: true, completed: false },
+            { name: 'Consultar Repositórios', required: true, completed: false },
+            { name: 'Aplicar Aprendizados', required: true, completed: false },
+            { name: 'Registrar Resultado', required: true, completed: false },
+            { name: 'Gerar Aprendizados', required: false, completed: false }
+        ];
+    }
+
+    /**
+     * Marca um passo como completado
+     */
+    protected markStepCompleted(stepName: string, details?: any): void {
+        const step = this.workflowSteps.find(s => s.name === stepName);
+        if (step) {
+            step.completed = true;
+            step.timestamp = new Date();
+            step.details = details;
+        }
+    }
+
+    /**
+     * Atualiza detalhes de um passo
+     */
+    protected updateStepDetails(stepName: string, details: any): void {
+        const step = this.workflowSteps.find(s => s.name === stepName);
+        if (step) {
+            step.details = { ...step.details, ...details };
+        }
+    }
+
+    /**
+     * Retorna os passos do workflow para validação
+     */
+    getWorkflowSteps(): WorkflowStep[] {
+        return [...this.workflowSteps];
+    }
+
+    /**
+     * Consulta repositórios de referência relevantes
+     */
+    protected async consultReferenceRepositories(): Promise<void> {
+        try {
+            if (!fs.existsSync(this.referenceReposPath)) {
+                console.log(`⚠️  [${this.agentName}] Arquivo de repositórios não encontrado`);
+                return;
+            }
+
+            const repos = JSON.parse(fs.readFileSync(this.referenceReposPath, 'utf-8'));
+            const relevantRepos = this.getRelevantRepositories(repos);
+
+            if (relevantRepos.length > 0) {
+                console.log(`\n📚 [${this.agentName}] Consultando repositórios de referência:`);
+                relevantRepos.forEach(repo => {
+                    console.log(`   - ${repo.name}: ${repo.url}`);
+                });
+            }
+        } catch (error: any) {
+            console.log(`⚠️  [${this.agentName}] Erro ao consultar repositórios:`, error.message);
+        }
+    }
+
+    /**
+     * Retorna repositórios relevantes para este agente (pode ser sobrescrito)
+     */
+    protected getRelevantRepositories(repos: any): Array<{ name: string; url: string }> {
+        // Implementação padrão - pode ser sobrescrita por agentes específicos
+        return [];
+    }
+
+    /**
+     * Aplica aprendizados com alta confiança
+     */
+    protected applyHighConfidenceLearnings(recommendations: string[]): void {
+        const memory = this.memory.loadMemory(this.agentName);
+        const highConfidenceLearnings = memory.learnings.filter(l => l.confidence > 0.7);
+
+        if (highConfidenceLearnings.length > 0) {
+            console.log(`\n🎯 [${this.agentName}] Aplicando ${highConfidenceLearnings.length} aprendizado(s) de alta confiança:`);
+            highConfidenceLearnings.forEach((learning, index) => {
+                console.log(`   ${index + 1}. ${learning.recommendation} (confiança: ${(learning.confidence * 100).toFixed(0)}%)`);
+            });
+        }
+    }
+}

package/.agents/core/cache-manager.test.ts

@@ -0,0 +1,147 @@
+/**
+ * Testes para CacheManager
+ */
+
+import { CacheManager } from './cache-manager';
+
+describe('CacheManager', () => {
+    let cache: CacheManager;
+
+    beforeEach(() => {
+        cache = new CacheManager(1000, 100); // 1s TTL, max 100 entries
+    });
+
+    afterEach(() => {
+        cache.clear();
+    });
+
+    describe('get and set', () => {
+        test('deve armazenar e recuperar valores', () => {
+            cache.set('key1', 'value1');
+            const result = cache.get<string>('key1');
+
+            expect(result).toBe('value1');
+        });
+
+        test('deve retornar null para chave inexistente', () => {
+            const result = cache.get('nonexistent');
+
+            expect(result).toBeNull();
+        });
+
+        test('deve expirar entradas após TTL', async () => {
+            cache.set('key1', 'value1', 100); // 100ms TTL
+
+            expect(cache.get('key1')).toBe('value1');
+
+            await new Promise(resolve => setTimeout(resolve, 150));
+
+            expect(cache.get('key1')).toBeNull();
+        });
+
+        test('deve usar TTL customizado', async () => {
+            cache.set('key1', 'value1', 200); // 200ms TTL
+
+            await new Promise(resolve => setTimeout(resolve, 150));
+            expect(cache.get('key1')).toBe('value1'); // Ainda válido
+
+            await new Promise(resolve => setTimeout(resolve, 100));
+            expect(cache.get('key1')).toBeNull(); // Expirou
+        });
+    });
+
+    describe('statistics', () => {
+        test('deve rastrear hits e misses', () => {
+            cache.set('key1', 'value1');
+
+            cache.get('key1'); // hit
+            cache.get('key2'); // miss
+            cache.get('key1'); // hit
+
+            const stats = cache.getStats();
+
+            expect(stats.hits).toBe(2);
+            expect(stats.misses).toBe(1);
+            expect(stats.hitRate).toBeCloseTo(66.67, 1);
+        });
+
+        test('deve resetar estatísticas', () => {
+            cache.set('key1', 'value1');
+            cache.get('key1');
+            cache.get('key2');
+
+            cache.resetStats();
+            const stats = cache.getStats();
+
+            expect(stats.hits).toBe(0);
+            expect(stats.misses).toBe(0);
+        });
+    });
+
+    describe('cleanup', () => {
+        test('deve remover entradas expiradas', async () => {
+            cache.set('key1', 'value1', 100);
+            cache.set('key2', 'value2', 1000);
+
+            await new Promise(resolve => setTimeout(resolve, 150));
+
+            const removed = cache.cleanup();
+
+            expect(removed).toBe(1);
+            expect(cache.size()).toBe(1);
+            expect(cache.get('key2')).toBe('value2');
+        });
+    });
+
+    describe('LRU eviction', () => {
+        test('deve remover entrada menos usada quando atingir limite', () => {
+            const smallCache = new CacheManager(1000, 3);
+
+            smallCache.set('key1', 'value1');
+            smallCache.set('key2', 'value2');
+            smallCache.set('key3', 'value3');
+
+            // Acessar key1 e key2 para aumentar hits
+            smallCache.get('key1');
+            smallCache.get('key2');
+
+            // Adicionar key4 deve remover key3 (menos usada)
+            smallCache.set('key4', 'value4');
+
+            expect(smallCache.has('key3')).toBe(false);
+            expect(smallCache.has('key1')).toBe(true);
+            expect(smallCache.size()).toBe(3);
+        });
+    });
+
+    describe('has', () => {
+        test('deve verificar existência de chave', () => {
+            cache.set('key1', 'value1');
+
+            expect(cache.has('key1')).toBe(true);
+            expect(cache.has('key2')).toBe(false);
+        });
+
+        test('deve retornar false para chave expirada', async () => {
+            cache.set('key1', 'value1', 100);
+
+            expect(cache.has('key1')).toBe(true);
+
+            await new Promise(resolve => setTimeout(resolve, 150));
+
+            expect(cache.has('key1')).toBe(false);
+        });
+    });
+
+    describe('clear', () => {
+        test('deve limpar todo o cache', () => {
+            cache.set('key1', 'value1');
+            cache.set('key2', 'value2');
+
+            cache.clear();
+
+            expect(cache.size()).toBe(0);
+            expect(cache.get('key1')).toBeNull();
+        });
+    });
+});