wegho-agentes 4.0.1

package/.agents/core/memory-system.ts

@@ -0,0 +1,397 @@
+/**
+ * Memory System - Sistema de Memória para Agentes
+ * 
+ * Responsabilidades:
+ * - Gerenciar memória persistente de cada agente
+ * - Registrar sucessos e falhas
+ * - Armazenar aprendizados
+ * - Buscar casos similares
+ * - Fornecer recomendações baseadas em histórico
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { CacheManager } from './cache-manager';
+
+/**
+ * Entrada individual de memória
+ */
+export interface MemoryEntry {
+    id: string;
+    timestamp: Date;
+    taskDescription: string;
+    context: {
+        files: string[];
+        areas: string[];
+        complexity: 'low' | 'medium' | 'high';
+    };
+    result: 'success' | 'failure';
+    details: string;
+    userFeedback?: {
+        satisfied: boolean;
+        likes: string[];
+        dislikes: string[];
+        suggestions: string[];
+    };
+    metadata?: Record<string, any>;
+}
+
+/**
+ * Padrão aprendido
+ */
+export interface Learning {
+    id: string;
+    pattern: string;
+    description: string;
+    recommendation: string;
+    confidence: number; // 0-1
+    occurrences: number;
+    lastSeen: Date;
+    examples: string[]; // IDs de MemoryEntry
+}
+
+/**
+ * Estrutura de memória de um agente
+ */
+export interface AgentMemory {
+    agentName: string;
+    successes: MemoryEntry[];
+    failures: MemoryEntry[];
+    learnings: Learning[];
+    stats: {
+        totalTasks: number;
+        successRate: number;
+        lastUpdated: Date;
+    };
+}
+
+/**
+ * Sistema de Memória
+ */
+export class MemorySystem {
+    private memoryBasePath: string;
+    private maxEntries: number;
+    private cache: CacheManager;
+
+    constructor(memoryBasePath: string = '.agents/memory', maxEntries: number = 1000) {
+        this.memoryBasePath = memoryBasePath;
+        this.maxEntries = maxEntries;
+        this.cache = new CacheManager(300000, 500); // 5 min TTL, max 500 entries
+        this.ensureMemoryStructure();
+    }
+
+    /**
+     * Garante que a estrutura de pastas existe
+     */
+    private ensureMemoryStructure(): void {
+        if (!fs.existsSync(this.memoryBasePath)) {
+            fs.mkdirSync(this.memoryBasePath, { recursive: true });
+        }
+    }
+
+    /**
+     * Garante que a pasta do agente existe
+     */
+    private ensureAgentFolder(agentName: string): string {
+        const agentPath = path.join(this.memoryBasePath, agentName);
+        if (!fs.existsSync(agentPath)) {
+            fs.mkdirSync(agentPath, { recursive: true });
+        }
+        return agentPath;
+    }
+
+    /**
+     * Carrega memória de um agente
+     */
+    loadMemory(agentName: string): AgentMemory {
+        const agentPath = this.ensureAgentFolder(agentName);
+
+        const successesPath = path.join(agentPath, 'successes.json');
+        const failuresPath = path.join(agentPath, 'failures.json');
+        const learningsPath = path.join(agentPath, 'learnings.json');
+
+        const successes = this.loadJsonFile<MemoryEntry[]>(successesPath, []);
+        const failures = this.loadJsonFile<MemoryEntry[]>(failuresPath, []);
+        const learnings = this.loadJsonFile<Learning[]>(learningsPath, []);
+
+        const totalTasks = successes.length + failures.length;
+        const successRate = totalTasks > 0 ? successes.length / totalTasks : 0;
+
+        return {
+            agentName,
+            successes,
+            failures,
+            learnings,
+            stats: {
+                totalTasks,
+                successRate,
+                lastUpdated: new Date(),
+            },
+        };
+    }
+
+    /**
+     * Salva memória de um agente
+     */
+    saveMemory(memory: AgentMemory): void {
+        const agentPath = this.ensureAgentFolder(memory.agentName);
+
+        // Limitar número de entradas
+        const successes = this.limitEntries(memory.successes);
+        const failures = this.limitEntries(memory.failures);
+
+        this.saveJsonFile(path.join(agentPath, 'successes.json'), successes);
+        this.saveJsonFile(path.join(agentPath, 'failures.json'), failures);
+        this.saveJsonFile(path.join(agentPath, 'learnings.json'), memory.learnings);
+    }
+
+    /**
+     * Registra um sucesso
+     */
+    recordSuccess(
+        agentName: string,
+        taskDescription: string,
+        context: MemoryEntry['context'],
+        details: string,
+        userFeedback?: MemoryEntry['userFeedback']
+    ): void {
+        const memory = this.loadMemory(agentName);
+
+        const entry: MemoryEntry = {
+            id: this.generateId(),
+            timestamp: new Date(),
+            taskDescription,
+            context,
+            result: 'success',
+            details,
+            userFeedback,
+        };
+
+        memory.successes.push(entry);
+        this.saveMemory(memory);
+
+        console.log(`✅ [${agentName}] Sucesso registrado: ${taskDescription}`);
+    }
+
+    /**
+     * Registra uma falha
+     */
+    recordFailure(
+        agentName: string,
+        taskDescription: string,
+        context: MemoryEntry['context'],
+        details: string,
+        userFeedback?: MemoryEntry['userFeedback']
+    ): void {
+        const memory = this.loadMemory(agentName);
+
+        const entry: MemoryEntry = {
+            id: this.generateId(),
+            timestamp: new Date(),
+            taskDescription,
+            context,
+            result: 'failure',
+            details,
+            userFeedback,
+        };
+
+        memory.failures.push(entry);
+        this.saveMemory(memory);
+
+        console.log(`❌ [${agentName}] Falha registrada: ${taskDescription}`);
+    }
+
+    /**
+     * Adiciona um aprendizado
+     */
+    addLearning(
+        agentName: string,
+        pattern: string,
+        description: string,
+        recommendation: string,
+        exampleIds: string[] = []
+    ): void {
+        const memory = this.loadMemory(agentName);
+
+        // Verificar se já existe
+        const existing = memory.learnings.find(l => l.pattern === pattern);
+
+        if (existing) {
+            existing.occurrences++;
+            existing.lastSeen = new Date();
+            existing.confidence = Math.min(1, existing.confidence + 0.1);
+            existing.examples.push(...exampleIds);
+        } else {
+            const learning: Learning = {
+                id: this.generateId(),
+                pattern,
+                description,
+                recommendation,
+                confidence: 0.5,
+                occurrences: 1,
+                lastSeen: new Date(),
+                examples: exampleIds,
+            };
+            memory.learnings.push(learning);
+        }
+
+        this.saveMemory(memory);
+        console.log(`🧠 [${agentName}] Aprendizado adicionado: ${pattern}`);
+    }
+
+    /**
+     * Busca casos similares
+     */
+    getSimilarCases(
+        agentName: string,
+        taskDescription: string,
+        limit: number = 5
+    ): MemoryEntry[] {
+        // Verificar cache primeiro
+        const cacheKey = `similar:${agentName}:${taskDescription}:${limit}`;
+        const cached = this.cache.get<MemoryEntry[]>(cacheKey);
+
+        if (cached) {
+            return cached;
+        }
+
+        // Cache miss - buscar do disco
+        const memory = this.loadMemory(agentName);
+        const allEntries = [...memory.successes, ...memory.failures];
+
+        // Busca simples por palavras-chave
+        const keywords = this.extractKeywords(taskDescription);
+
+        const scored = allEntries.map(entry => {
+            const entryKeywords = this.extractKeywords(entry.taskDescription);
+            const score = this.calculateSimilarity(keywords, entryKeywords);
+            return { entry, score };
+        });
+
+        const results = scored
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit)
+            .filter(s => s.score > 0.3)
+            .map(s => s.entry);
+
+        // Cachear resultado
+        this.cache.set(cacheKey, results, 60000); // 1 minuto TTL
+
+        return results;
+    }
+
+    /**
+     * Obtém recomendações baseadas em aprendizados
+     */
+    getRecommendations(agentName: string, taskDescription: string): string[] {
+        // Verificar cache primeiro
+        const cacheKey = `recommendations:${agentName}:${taskDescription}`;
+        const cached = this.cache.get<string[]>(cacheKey);
+
+        if (cached) {
+            return cached;
+        }
+
+        // Cache miss - buscar do disco
+        const memory = this.loadMemory(agentName);
+        const keywords = this.extractKeywords(taskDescription);
+
+        const results = memory.learnings
+            .filter(learning => {
+                const patternKeywords = this.extractKeywords(learning.pattern);
+                const similarity = this.calculateSimilarity(keywords, patternKeywords);
+                return similarity > 0.3 && learning.confidence > 0.5;
+            })
+            .sort((a, b) => b.confidence - a.confidence)
+            .map(l => l.recommendation);
+
+        // Cachear resultado
+        this.cache.set(cacheKey, results, 120000); // 2 minutos TTL
+
+        return results;
+    }
+
+    /**
+     * Obtém estatísticas do cache
+     */
+    getCacheStats() {
+        return this.cache.getStats();
+    }
+
+    /**
+     * Limpa o cache
+     */
+    clearCache(): void {
+        this.cache.clear();
+    }
+
+    /**
+     * Obtém estatísticas de um agente
+     */
+    getStats(agentName: string): AgentMemory['stats'] {
+        const memory = this.loadMemory(agentName);
+        return memory.stats;
+    }
+
+    // ==================== Métodos Auxiliares ====================
+
+    private loadJsonFile<T>(filePath: string, defaultValue: T): T {
+        try {
+            if (fs.existsSync(filePath)) {
+                const content = fs.readFileSync(filePath, 'utf-8');
+                const data = JSON.parse(content);
+
+                // Robustez: se o arquivo JSON estiver envolto em um objeto (ex: { "successes": [] })
+                // extraímos o array diretamente
+                const fileName = path.basename(filePath, '.json');
+                if (data && typeof data === 'object' && !Array.isArray(data) && data[fileName]) {
+                    return data[fileName] as T;
+                }
+
+                return data;
+            }
+        } catch (error) {
+            console.warn(`Erro ao carregar ${filePath}:`, error);
+        }
+        return defaultValue;
+    }
+
+    private saveJsonFile(filePath: string, data: any): void {
+        try {
+            fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
+        } catch (error) {
+            console.error(`Erro ao salvar ${filePath}:`, error);
+        }
+    }
+
+    private limitEntries<T extends MemoryEntry>(entries: T[]): T[] {
+        if (entries.length <= this.maxEntries) {
+            return entries;
+        }
+        // Manter as mais recentes
+        return entries
+            .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime())
+            .slice(0, this.maxEntries);
+    }
+
+    private generateId(): string {
+        return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+
+    private extractKeywords(text: string): string[] {
+        return text
+            .toLowerCase()
+            .replace(/[^\w\s]/g, ' ')
+            .split(/\s+/)
+            .filter(word => word.length > 3);
+    }
+
+    private calculateSimilarity(keywords1: string[], keywords2: string[]): number {
+        const set1 = new Set(keywords1);
+        const set2 = new Set(keywords2);
+        const intersection = new Set([...set1].filter(k => set2.has(k)));
+        const union = new Set([...set1, ...set2]);
+
+        return union.size > 0 ? intersection.size / union.size : 0;
+    }
+}

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

@@ -0,0 +1,268 @@
+/**
+ * Quality Agent (com Memória)
+ * 
+ * Responsabilidades:
+ * - Executar lint (ESLint)
+ * - Executar type check (TypeScript)
+ * - Executar build
+ * - Executar testes
+ * - Dar decisão final GO/NO-GO
+ * - Aprender com falhas de build recorrentes
+ */
+
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+import { BaseAgent, TaskContext, TaskResult } from './base-agent';
+
+export interface QualityCheckResult extends TaskResult {
+    checks: {
+        lint: { passed: boolean; errors: number; warnings: number };
+        typecheck: { passed: boolean; errors: number };
+        build: { passed: boolean; error?: string };
+        tests: { passed: boolean; total: number; failed: number };
+    };
+    decision: 'GO' | 'NO-GO';
+}
+
+export class QualityAgent extends BaseAgent {
+    constructor(memoryBasePath: string = '.agents/memory') {
+        super('quality-agent', memoryBasePath);
+    }
+
+    /**
+     * Implementação da validação de qualidade
+     */
+    async executeTask(taskDescription: string, context: TaskContext): Promise<TaskResult> {
+        console.log('\n🔍 Executando validações de qualidade...\n');
+
+        const checks = {
+            lint: await this.runLint(),
+            typecheck: await this.runTypeCheck(),
+            build: await this.runBuild(),
+            tests: await this.runTests()
+        };
+
+        // Decisão GO/NO-GO
+        const decision = this.makeDecision(checks);
+
+        const success = decision === 'GO';
+        const details = this.formatChecks(checks, decision);
+
+        const issues: string[] = [];
+        if (!checks.lint.passed) issues.push(`Lint: ${checks.lint.errors} erro(s)`);
+        if (!checks.typecheck.passed) issues.push(`TypeCheck: ${checks.typecheck.errors} erro(s)`);
+        if (!checks.build.passed) issues.push('Build falhou');
+        if (!checks.tests.passed) issues.push(`Tests: ${checks.tests.failed} falhou(ram)`);
+
+        return {
+            success,
+            details,
+            issues: issues.length > 0 ? issues : undefined,
+        };
+    }
+
+    /**
+     * Executa lint
+     */
+    private async runLint(): Promise<{ passed: boolean; errors: number; warnings: number }> {
+        console.log('  📝 Executando lint...');
+
+        return new Promise((resolve) => {
+            // Verificar se package.json tem script de lint
+            if (!this.hasScript('lint')) {
+                console.log('     ⏭️  Lint não configurado');
+                resolve({ passed: true, errors: 0, warnings: 0 });
+                return;
+            }
+
+            const lint = spawn('npm', ['run', 'lint'], { shell: true });
+
+            let output = '';
+            lint.stdout.on('data', (data) => { output += data.toString(); });
+            lint.stderr.on('data', (data) => { output += data.toString(); });
+
+            lint.on('close', (code) => {
+                const errors = (output.match(/error/gi) || []).length;
+                const warnings = (output.match(/warning/gi) || []).length;
+                const passed = code === 0;
+
+                console.log(`     ${passed ? '✅' : '❌'} Lint: ${errors} erro(s), ${warnings} aviso(s)`);
+                resolve({ passed, errors, warnings });
+            });
+
+            lint.on('error', () => {
+                resolve({ passed: false, errors: 1, warnings: 0 });
+            });
+        });
+    }
+
+    /**
+     * Executa type check
+     */
+    private async runTypeCheck(): Promise<{ passed: boolean; errors: number }> {
+        console.log('  🔤 Executando type check...');
+
+        return new Promise((resolve) => {
+            const tsc = spawn('npx', ['tsc', '--noEmit'], { shell: true });
+
+            let output = '';
+            tsc.stdout.on('data', (data) => { output += data.toString(); });
+            tsc.stderr.on('data', (data) => { output += data.toString(); });
+
+            tsc.on('close', (code) => {
+                const errors = (output.match(/error TS/g) || []).length;
+                const passed = code === 0;
+
+                console.log(`     ${passed ? '✅' : '❌'} TypeCheck: ${errors} erro(s)`);
+                resolve({ passed, errors });
+            });
+
+            tsc.on('error', () => {
+                console.log('     ⏭️  TypeScript não disponível');
+                resolve({ passed: true, errors: 0 });
+            });
+        });
+    }
+
+    /**
+     * Executa build
+     */
+    private async runBuild(): Promise<{ passed: boolean; error?: string }> {
+        console.log('  🏗️  Executando build...');
+
+        return new Promise((resolve) => {
+            if (!this.hasScript('build')) {
+                console.log('     ⏭️  Build não configurado');
+                resolve({ passed: true });
+                return;
+            }
+
+            const build = spawn('npm', ['run', 'build'], { shell: true });
+
+            let output = '';
+            build.stdout.on('data', (data) => { output += data.toString(); });
+            build.stderr.on('data', (data) => { output += data.toString(); });
+
+            build.on('close', (code) => {
+                const passed = code === 0;
+                const error = passed ? undefined : output.substring(0, 500);
+
+                console.log(`     ${passed ? '✅' : '❌'} Build ${passed ? 'passou' : 'falhou'}`);
+                resolve({ passed, error });
+            });
+
+            build.on('error', () => {
+                resolve({ passed: false, error: 'Erro ao executar build' });
+            });
+        });
+    }
+
+    /**
+     * Executa testes
+     */
+    private async runTests(): Promise<{ passed: boolean; total: number; failed: number }> {
+        console.log('  🧪 Executando testes...');
+
+        return new Promise((resolve) => {
+            if (!this.hasScript('test')) {
+                console.log('     ⏭️  Testes não configurados');
+                resolve({ passed: true, total: 0, failed: 0 });
+                return;
+            }
+
+            const test = spawn('npm', ['run', 'test', '--', '--passWithNoTests'], { shell: true });
+
+            let output = '';
+            test.stdout.on('data', (data) => { output += data.toString(); });
+            test.stderr.on('data', (data) => { output += data.toString(); });
+
+            test.on('close', (code) => {
+                const passed = code === 0;
+                const total = (output.match(/Tests:.*?(\d+) total/)?.[1] || '0');
+                const failed = (output.match(/Tests:.*?(\d+) failed/)?.[1] || '0');
+
+                console.log(`     ${passed ? '✅' : '❌'} Tests: ${failed} falhou(ram) de ${total}`);
+                resolve({ passed, total: parseInt(total), failed: parseInt(failed) });
+            });
+
+            test.on('error', () => {
+                resolve({ passed: true, total: 0, failed: 0 });
+            });
+        });
+    }
+
+    /**
+     * Verifica se script existe no package.json
+     */
+    private hasScript(scriptName: string): boolean {
+        try {
+            const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf-8'));
+            return !!packageJson.scripts?.[scriptName];
+        } catch {
+            return false;
+        }
+    }
+
+    /**
+     * Toma decisão GO/NO-GO
+     */
+    private makeDecision(checks: QualityCheckResult['checks']): 'GO' | 'NO-GO' {
+        // Bloqueadores: lint errors, type errors, build failed
+        if (checks.lint.errors > 0) return 'NO-GO';
+        if (checks.typecheck.errors > 0) return 'NO-GO';
+        if (!checks.build.passed) return 'NO-GO';
+        if (!checks.tests.passed) return 'NO-GO';
+
+        return 'GO';
+    }
+
+    /**
+     * Formata resultado dos checks
+     */
+    private formatChecks(checks: QualityCheckResult['checks'], decision: 'GO' | 'NO-GO'): string {
+        let details = `Decisão: ${decision}\n`;
+        details += `Lint: ${checks.lint.passed ? 'OK' : 'FALHOU'}\n`;
+        details += `TypeCheck: ${checks.typecheck.passed ? 'OK' : 'FALHOU'}\n`;
+        details += `Build: ${checks.build.passed ? 'OK' : 'FALHOU'}\n`;
+        details += `Tests: ${checks.tests.passed ? 'OK' : 'FALHOU'}`;
+        return details;
+    }
+
+    /**
+     * Especialidade padrão do Quality Agent
+     */
+    protected getDefaultSpecialty(): string {
+        return `# Quality Agent - Especialidade
+
+## Responsabilidades
+- Executar lint (ESLint)
+- Executar type check (TypeScript)
+- Executar build
+- Executar testes unitários e integração
+- Dar decisão final GO/NO-GO
+- Garantir qualidade do código
+
+## Expertise
+- Testing (Jest, Vitest, Playwright, Cypress)
+- Linting (ESLint, Prettier)
+- TypeScript
+- CI/CD
+- Code Quality Metrics
+- Test Coverage
+
+## Regras
+- Zero erros de lint (warnings são aceitáveis)
+- Zero erros de type check
+- Build deve passar
+- Todos os testes devem passar
+- Cobertura de testes > 80% (recomendado)
+
+## Tarefas Típicas
+- Validar qualidade antes de commit
+- Executar suite completa de testes
+- Dar GO/NO-GO para deploy
+- Identificar problemas de qualidade
+- Sugerir melhorias de código
+`;
+    }
+}