wegho-agentes 7.0.0 → 7.0.1

package/.agents/utils/memory-converter.ts

@@ -1,217 +0,0 @@
-/**
- * Memory Converter - Converte memória JSON para Markdown
- * 
- * Responsabilidades:
- * - Ler arquivos JSON de memória (successes, failures, learnings)
- * - Converter para formato markdown estruturado
- * - Preservar toda informação histórica
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-
-interface MemoryEntry {
-    id: string;
-    timestamp: string;
-    taskDescription: string;
-    context: {
-        files: string[];
-        areas: string[];
-        complexity: 'low' | 'medium' | 'high';
-    };
-    result: string;
-    details: string;
-    userFeedback?: {
-        satisfied: boolean;
-        likes: string[];
-        dislikes: string[];
-        suggestions: string[];
-    };
-}
-
-interface Learning {
-    pattern: string;
-    description: string;
-    recommendation: string;
-    confidence: number;
-    exampleIds: string[];
-    createdAt: string;
-}
-
-export class MemoryConverter {
-    /**
-     * Converte memória de um agente de JSON para MD
-     */
-    static convertAgentMemory(agentName: string, memoryBasePath: string): string {
-        const agentMemoryPath = path.join(memoryBasePath, agentName);
-        
-        // Ler arquivos JSON
-        const successes = this.readJsonFile<MemoryEntry[]>(path.join(agentMemoryPath, 'successes.json')) || [];
-        const failures = this.readJsonFile<MemoryEntry[]>(path.join(agentMemoryPath, 'failures.json')) || [];
-        const learnings = this.readJsonFile<Learning[]>(path.join(agentMemoryPath, 'learnings.json')) || [];
-
-        // Calcular estatísticas
-        const totalSuccesses = successes.length;
-        const totalFailures = failures.length;
-        const totalTasks = totalSuccesses + totalFailures;
-        const successRate = totalTasks > 0 ? ((totalSuccesses / totalTasks) * 100).toFixed(1) : '0.0';
-
-        // Gerar markdown
-        let markdown = `# Memória do Agente ${agentName}\n\n`;
-        markdown += `Última atualização: ${new Date().toISOString()}\n\n`;
-        markdown += `---\n\n`;
-
-        // Estatísticas
-        markdown += `## 📊 Estatísticas\n\n`;
-        markdown += `- Total de sucessos: ${totalSuccesses}\n`;
-        markdown += `- Total de falhas: ${totalFailures}\n`;
-        markdown += `- Taxa de sucesso: ${successRate}%\n`;
-        markdown += `- Aprendizados acumulados: ${learnings.length}\n\n`;
-        markdown += `---\n\n`;
-
-        // Sucessos recentes (últimos 10)
-        markdown += `## ✅ Sucessos Recentes\n\n`;
-        const recentSuccesses = successes.slice(-10).reverse();
-        
-        if (recentSuccesses.length === 0) {
-            markdown += `_Nenhum sucesso registrado ainda._\n\n`;
-        } else {
-            recentSuccesses.forEach(entry => {
-                const date = new Date(entry.timestamp).toLocaleDateString('pt-BR');
-                markdown += `### ${date} - \`${entry.id}\`\n\n`;
-                markdown += `**Tarefa**: ${entry.taskDescription}\n\n`;
-                markdown += `**Contexto**:\n`;
-                markdown += `- Arquivos: ${entry.context.files.length > 0 ? entry.context.files.join(', ') : 'nenhum'}\n`;
-                markdown += `- Áreas: ${entry.context.areas.join(', ')}\n`;
-                markdown += `- Complexidade: ${entry.complexity || entry.context.complexity}\n\n`;
-                markdown += `**Resultado**: ${entry.details}\n\n`;
-                
-                if (entry.userFeedback) {
-                    const emoji = entry.userFeedback.satisfied ? '👍' : '👎';
-                    markdown += `**Feedback do usuário**: ${emoji}\n`;
-                    if (entry.userFeedback.likes.length > 0) {
-                        markdown += `- Gostou: ${entry.userFeedback.likes.join(', ')}\n`;
-                    }
-                    if (entry.userFeedback.dislikes.length > 0) {
-                        markdown += `- Não gostou: ${entry.userFeedback.dislikes.join(', ')}\n`;
-                    }
-                    if (entry.userFeedback.suggestions.length > 0) {
-                        markdown += `- Sugestões: ${entry.userFeedback.suggestions.join(', ')}\n`;
-                    }
-                    markdown += '\n';
-                }
-            });
-        }
-
-        markdown += `---\n\n`;
-
-        // Falhas registradas (últimas 10)
-        markdown += `## ❌ Falhas Registradas\n\n`;
-        const recentFailures = failures.slice(-10).reverse();
-        
-        if (recentFailures.length === 0) {
-            markdown += `_Nenhuma falha registrada._\n\n`;
-        } else {
-            recentFailures.forEach(entry => {
-                const date = new Date(entry.timestamp).toLocaleDateString('pt-BR');
-                markdown += `### ${date} - \`${entry.id}\`\n\n`;
-                markdown += `**Tarefa**: ${entry.taskDescription}\n\n`;
-                markdown += `**Motivo**: ${entry.details}\n\n`;
-                
-                if (entry.userFeedback && entry.userFeedback.suggestions.length > 0) {
-                    markdown += `**Lição aprendida**: ${entry.userFeedback.suggestions.join('; ')}\n\n`;
-                }
-            });
-        }
-
-        markdown += `---\n\n`;
-
-        // Aprendizados
-        markdown += `## 🧠 Aprendizados\n\n`;
-        
-        if (learnings.length === 0) {
-            markdown += `_Nenhum aprendizado registrado ainda._\n\n`;
-        } else {
-            learnings.forEach((learning, index) => {
-                markdown += `### Aprendizado ${index + 1}\n\n`;
-                markdown += `**Padrão**: ${learning.pattern}\n\n`;
-                markdown += `**Descrição**: ${learning.description}\n\n`;
-                markdown += `**Recomendação**: ${learning.recommendation}\n\n`;
-                markdown += `**Confiança**: ${(learning.confidence * 100).toFixed(0)}%\n\n`;
-                
-                if (learning.exampleIds.length > 0) {
-                    markdown += `**Exemplos**: ${learning.exampleIds.map(id => `\`${id}\``).join(', ')}\n\n`;
-                }
-                
-                if (learning.createdAt) {
-                    const date = new Date(learning.createdAt).toLocaleDateString('pt-BR');
-                    markdown += `_Criado em: ${date}_\n\n`;
-                }
-            });
-        }
-
-        return markdown;
-    }
-
-    /**
-     * Lê arquivo JSON com tratamento de erros
-     */
-    private static readJsonFile<T>(filePath: string): T | null {
-        try {
-            if (!fs.existsSync(filePath)) {
-                return null;
-            }
-            const content = fs.readFileSync(filePath, 'utf-8');
-            return JSON.parse(content) as T;
-        } catch (error) {
-            console.warn(`⚠️  Erro ao ler ${filePath}:`, error);
-            return null;
-        }
-    }
-
-    /**
-     * Converte todos os agentes em um diretório
-     */
-    static convertAllAgents(memoryBasePath: string, outputBasePath: string): void {
-        if (!fs.existsSync(memoryBasePath)) {
-            console.error(`❌ Pasta de memória não encontrada: ${memoryBasePath}`);
-            return;
-        }
-
-        const agentDirs = fs.readdirSync(memoryBasePath, { withFileTypes: true })
-            .filter(dirent => dirent.isDirectory())
-            .map(dirent => dirent.name);
-
-        console.log(`🔄 Convertendo memória de ${agentDirs.length} agentes...\n`);
-
-        agentDirs.forEach(agentName => {
-            try {
-                const markdown = this.convertAgentMemory(agentName, memoryBasePath);
-                
-                // Criar pasta de destino
-                const agentOutputPath = path.join(outputBasePath, agentName);
-                if (!fs.existsSync(agentOutputPath)) {
-                    fs.mkdirSync(agentOutputPath, { recursive: true });
-                }
-
-                // Salvar memory.md
-                const outputFile = path.join(agentOutputPath, 'memory.md');
-                fs.writeFileSync(outputFile, markdown, 'utf-8');
-                
-                console.log(`✅ ${agentName} → ${outputFile}`);
-            } catch (error: any) {
-                console.error(`❌ Erro ao converter ${agentName}:`, error.message);
-            }
-        });
-
-        console.log(`\n✅ Conversão concluída!`);
-    }
-}
-
-// CLI para execução standalone
-if (require.main === module) {
-    const memoryBasePath = path.join(process.cwd(), '.agents', 'memory');
-    const outputBasePath = path.join(process.cwd(), '.agents', 'agents');
-    
-    MemoryConverter.convertAllAgents(memoryBasePath, outputBasePath);
-}

package/.agents/utils/memory-dashboard.ts

@@ -1,147 +0,0 @@
-/**
- * Memory Dashboard - Dashboard de memórias por agente
- */
-
-import { MemorySystem } from '../base/memory-system.js';
-
-export interface MemorySummary {
-    agentName: string;
-    goodMemories: {
-        count: number;
-        examples: string[];
-    };
-    badMemories: {
-        count: number;
-        examples: string[];
-    };
-    totalTasks: number;
-    successRate: number;
-}
-
-export class MemoryDashboard {
-    /**
-     * Gera dashboard completo de memórias de todos os agentes
-     */
-    generateFullDashboard(agentNames: string[], memoryPath: string = '.agents/memory'): string {
-        let dashboard = '\\n📊 DASHBOARD DE MEMÓRIAS\\n\\n';
-
-        for (const agentName of agentNames) {
-            const summary = this.getAgentMemorySummary(agentName, memoryPath);
-            dashboard += this.formatAgentSection(summary);
-            dashboard += '\\n';
-        }
-
-        return dashboard;
-    }
-
-    /**
-     * Gera relatório de um agente específico
-     */
-    getAgentMemorySummary(agentName: string, memoryPath: string = '.agents/memory'): MemorySummary {
-        const memory = new MemorySystem(memoryPath);
-        const agentMemory = memory.loadMemory(agentName);
-
-        // Separar memórias boas e ruins
-        const goodMemories = agentMemory.successes;
-        const badMemories = agentMemory.failures;
-
-        // Pegar top 3 exemplos de cada
-        const goodExamples = goodMemories
-            .slice(-3)
-            .map(e => e.taskDescription);
-
-        const badExamples = badMemories
-            .slice(-3)
-            .map(e => e.taskDescription);
-
-        const totalTasks = goodMemories.length + badMemories.length;
-        const successRate = totalTasks > 0
-            ? Math.round((goodMemories.length / totalTasks) * 100)
-            : 0;
-
-        return {
-            agentName,
-            goodMemories: {
-                count: goodMemories.length,
-                examples: goodExamples
-            },
-            badMemories: {
-                count: badMemories.length,
-                examples: badExamples
-            },
-            totalTasks,
-            successRate
-        };
-    }
-
-    /**
-     * Formata seção de um agente para exibição
-     */
-    private formatAgentSection(summary: MemorySummary): string {
-        const boxWidth = 50;
-        const border = '─'.repeat(boxWidth);
-
-        let section = `┌${border}┐\\n`;
-        section += `│ ${this.pad(summary.agentName, boxWidth - 2)} │\\n`;
-        section += `├${border}┤\\n`;
-
-        // Memórias boas
-        section += `│ ✅ Memórias Boas: ${summary.goodMemories.count}${' '.repeat(boxWidth - 20 - summary.goodMemories.count.toString().length)} │\\n`;
-        if (summary.goodMemories.examples.length > 0) {
-            summary.goodMemories.examples.forEach(example => {
-                const truncated = this.truncate(example, boxWidth - 6);
-                section += `│   - ${this.pad(truncated, boxWidth - 6)} │\\n`;
-            });
-        }
-
-        section += `│${' '.repeat(boxWidth)}│\\n`;
-
-        // Memórias ruins
-        section += `│ ❌ Memórias Ruins: ${summary.badMemories.count}${' '.repeat(boxWidth - 21 - summary.badMemories.count.toString().length)} │\\n`;
-        if (summary.badMemories.examples.length > 0) {
-            summary.badMemories.examples.forEach(example => {
-                const truncated = this.truncate(example, boxWidth - 6);
-                section += `│   - ${this.pad(truncated, boxWidth - 6)} │\\n`;
-            });
-        }
-
-        section += `│${' '.repeat(boxWidth)}│\\n`;
-        section += `│ 📈 Taxa de Sucesso: ${summary.successRate}%${' '.repeat(boxWidth - 24 - summary.successRate.toString().length)} │\\n`;
-        section += `└${border}┘`;
-
-        return section;
-    }
-
-    /**
-     * Padding helper
-     */
-    private pad(text: string, width: number): string {
-        if (text.length >= width) return text.substring(0, width);
-        return text + ' '.repeat(width - text.length);
-    }
-
-    /**
-     * Truncate helper
-     */
-    private truncate(text: string, maxLength: number): string {
-        if (text.length <= maxLength) return text;
-        return text.substring(0, maxLength - 3) + '...';
-    }
-
-    /**
-     * Gera relatório resumido (apenas estatísticas)
-     */
-    generateQuickSummary(agentNames: string[], memoryPath: string = '.agents/memory'): string {
-        let summary = '📊 RESUMO DE MEMÓRIAS\\n\\n';
-
-        for (const agentName of agentNames) {
-            const mem = this.getAgentMemorySummary(agentName, memoryPath);
-            summary += `${agentName}: ✅ ${mem.goodMemories.count} | ❌ ${mem.badMemories.count} | 📈 ${mem.successRate}%\\n`;
-        }
-
-        return summary;
-    }
-}
-
-// Singleton global
-export const globalMemoryDashboard = new MemoryDashboard();

package/.agents/utils/performance-tracker.ts

@@ -1,275 +0,0 @@
-/**
- * Sistema de Métricas de Performance
- * 
- * Rastreia e analisa a performance de execução dos agentes,
- * incluindo duração de cada passo do workflow e identificação de bottlenecks.
- */
-
-export interface PerformanceMetric {
-    agentName: string;
-    taskId: string;
-    stepName: string;
-    startTime: number;
-    endTime: number;
-    duration: number;
-    success: boolean;
-    error?: string;
-}
-
-export interface AgentPerformanceSummary {
-    agentName: string;
-    totalExecutions: number;
-    successfulExecutions: number;
-    failedExecutions: number;
-    averageDuration: number;
-    minDuration: number;
-    maxDuration: number;
-    p50Duration: number;
-    p95Duration: number;
-    p99Duration: number;
-}
-
-export interface PerformanceReport {
-    taskId: string;
-    totalDuration: number;
-    agentMetrics: Map<string, AgentPerformanceSummary>;
-    bottlenecks: string[];
-    recommendations: string[];
-}
-
-export class PerformanceTracker {
-    private metrics: PerformanceMetric[] = [];
-    private activeTimers: Map<string, number> = new Map();
-
-    /**
-     * Inicia o rastreamento de uma operação
-     */
-    startTracking(agentName: string, taskId: string, stepName: string): string {
-        const trackingId = `${agentName}-${taskId}-${stepName}-${Date.now()}`;
-        this.activeTimers.set(trackingId, Date.now());
-        return trackingId;
-    }
-
-    /**
-     * Finaliza o rastreamento de uma operação
-     */
-    endTracking(trackingId: string, success: boolean, error?: string): void {
-        const startTime = this.activeTimers.get(trackingId);
-        if (!startTime) {
-            console.warn(`[PerformanceTracker] Tracking ID não encontrado: ${trackingId}`);
-            return;
-        }
-
-        const endTime = Date.now();
-        const [agentName, taskId, stepName] = trackingId.split('-');
-
-        const metric: PerformanceMetric = {
-            agentName,
-            taskId,
-            stepName,
-            startTime,
-            endTime,
-            duration: endTime - startTime,
-            success,
-            error
-        };
-
-        this.metrics.push(metric);
-        this.activeTimers.delete(trackingId);
-    }
-
-    /**
-     * Obtém métricas de um agente específico
-     */
-    getAgentMetrics(agentName: string): PerformanceMetric[] {
-        return this.metrics.filter(m => m.agentName === agentName);
-    }
-
-    /**
-     * Obtém métricas de uma tarefa específica
-     */
-    getTaskMetrics(taskId: string): PerformanceMetric[] {
-        return this.metrics.filter(m => m.taskId === taskId);
-    }
-
-    /**
-     * Calcula resumo de performance de um agente
-     */
-    getAgentSummary(agentName: string): AgentPerformanceSummary {
-        const agentMetrics = this.getAgentMetrics(agentName);
-
-        if (agentMetrics.length === 0) {
-            return {
-                agentName,
-                totalExecutions: 0,
-                successfulExecutions: 0,
-                failedExecutions: 0,
-                averageDuration: 0,
-                minDuration: 0,
-                maxDuration: 0,
-                p50Duration: 0,
-                p95Duration: 0,
-                p99Duration: 0
-            };
-        }
-
-        const durations = agentMetrics.map(m => m.duration).sort((a, b) => a - b);
-        const successfulExecutions = agentMetrics.filter(m => m.success).length;
-
-        return {
-            agentName,
-            totalExecutions: agentMetrics.length,
-            successfulExecutions,
-            failedExecutions: agentMetrics.length - successfulExecutions,
-            averageDuration: durations.reduce((a, b) => a + b, 0) / durations.length,
-            minDuration: durations[0],
-            maxDuration: durations[durations.length - 1],
-            p50Duration: this.calculatePercentile(durations, 50),
-            p95Duration: this.calculatePercentile(durations, 95),
-            p99Duration: this.calculatePercentile(durations, 99)
-        };
-    }
-
-    /**
-     * Gera relatório de performance completo para uma tarefa
-     */
-    generateReport(taskId: string): PerformanceReport {
-        const taskMetrics = this.getTaskMetrics(taskId);
-        const agentNames = [...new Set(taskMetrics.map(m => m.agentName))];
-
-        const agentMetrics = new Map<string, AgentPerformanceSummary>();
-        agentNames.forEach(name => {
-            agentMetrics.set(name, this.getAgentSummary(name));
-        });
-
-        const totalDuration = taskMetrics.reduce((sum, m) => sum + m.duration, 0);
-        const bottlenecks = this.identifyBottlenecks(agentMetrics);
-        const recommendations = this.generateRecommendations(agentMetrics, bottlenecks);
-
-        return {
-            taskId,
-            totalDuration,
-            agentMetrics,
-            bottlenecks,
-            recommendations
-        };
-    }
-
-    /**
-     * Identifica bottlenecks (agentes mais lentos)
-     */
-    private identifyBottlenecks(agentMetrics: Map<string, AgentPerformanceSummary>): string[] {
-        const bottlenecks: string[] = [];
-        const avgDurations: Array<{ name: string; duration: number }> = [];
-
-        agentMetrics.forEach((summary, name) => {
-            avgDurations.push({ name, duration: summary.averageDuration });
-        });
-
-        // Ordenar por duração (maior primeiro)
-        avgDurations.sort((a, b) => b.duration - a.duration);
-
-        // Considerar os 30% mais lentos como bottlenecks
-        const threshold = Math.ceil(avgDurations.length * 0.3);
-        for (let i = 0; i < threshold && i < avgDurations.length; i++) {
-            bottlenecks.push(avgDurations[i].name);
-        }
-
-        return bottlenecks;
-    }
-
-    /**
-     * Gera recomendações baseadas nas métricas
-     */
-    private generateRecommendations(
-        agentMetrics: Map<string, AgentPerformanceSummary>,
-        bottlenecks: string[]
-    ): string[] {
-        const recommendations: string[] = [];
-
-        // Recomendações para bottlenecks
-        bottlenecks.forEach(agentName => {
-            const summary = agentMetrics.get(agentName);
-            if (summary && summary.averageDuration > 10000) {
-                recommendations.push(
-                    `⚠️ ${agentName}: Duração média muito alta (${(summary.averageDuration / 1000).toFixed(2)}s). Considere otimização ou cache.`
-                );
-            }
-        });
-
-        // Recomendações para taxa de falha
-        agentMetrics.forEach((summary, name) => {
-            const failureRate = summary.failedExecutions / summary.totalExecutions;
-            if (failureRate > 0.1) {
-                recommendations.push(
-                    `🔴 ${name}: Taxa de falha alta (${(failureRate * 100).toFixed(1)}%). Investigar causas.`
-                );
-            }
-        });
-
-        // Recomendações para variabilidade
-        agentMetrics.forEach((summary, name) => {
-            const variability = summary.maxDuration / summary.minDuration;
-            if (variability > 5 && summary.totalExecutions > 5) {
-                recommendations.push(
-                    `📊 ${name}: Alta variabilidade na duração (${variability.toFixed(1)}x). Pode indicar dependências externas instáveis.`
-                );
-            }
-        });
-
-        if (recommendations.length === 0) {
-            recommendations.push('✅ Performance está dentro dos padrões esperados.');
-        }
-
-        return recommendations;
-    }
-
-    /**
-     * Calcula percentil de uma lista de valores
-     */
-    private calculatePercentile(sortedValues: number[], percentile: number): number {
-        if (sortedValues.length === 0) return 0;
-
-        const index = Math.ceil((percentile / 100) * sortedValues.length) - 1;
-        return sortedValues[Math.max(0, index)];
-    }
-
-    /**
-     * Limpa métricas antigas (mantém apenas últimas N)
-     */
-    clearOldMetrics(keepLast: number = 1000): void {
-        if (this.metrics.length > keepLast) {
-            this.metrics = this.metrics.slice(-keepLast);
-        }
-    }
-
-    /**
-     * Exporta métricas para JSON
-     */
-    exportMetrics(): string {
-        return JSON.stringify(this.metrics, null, 2);
-    }
-
-    /**
-     * Obtém estatísticas gerais
-     */
-    getStats(): {
-        totalMetrics: number;
-        totalAgents: number;
-        totalTasks: number;
-        averageDuration: number;
-    } {
-        const uniqueAgents = new Set(this.metrics.map(m => m.agentName));
-        const uniqueTasks = new Set(this.metrics.map(m => m.taskId));
-        const avgDuration = this.metrics.length > 0
-            ? this.metrics.reduce((sum, m) => sum + m.duration, 0) / this.metrics.length
-            : 0;
-
-        return {
-            totalMetrics: this.metrics.length,
-            totalAgents: uniqueAgents.size,
-            totalTasks: uniqueTasks.size,
-            averageDuration: avgDuration
-        };
-    }
-}